KSD 테스트 추가가

KSD01/listen.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+
+function toBytes32(data: string): BytesLike {
+    return hexlify(zeroPadValue(toUtf8Bytes(data), 32));
+}
+  
+/**
+ * Converts solidity byte32 to utf8 string
+ */
+function bytes32ToString(data: BytesLike): string {
+return toUtf8String(stripZerosLeft(data));
+}
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+// event TokenIssuableKSD2(
+//     bytes32 isin,
+//     uint256 totalIssueQty,
+//     bytes32[] KSDAccounts,
+//     uint256[] amounts,
+//     bytes32 slipSeqKSD
+// );
+
+async function listenIssuable(tokenAddress: string, operator: Wallet) {
+
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+    // token.on(token.filters.TokenIssuableKSD2,(isin,totalIssueQty,KSDAccounts,amounts,slipSeqKSD, event) => {
+    //     console.log(event);
+    // });
+
+    // token.on(token.filters.TokenIssuableKSD,(isin,slipSeqKSD, event) => {
+    //     console.log(event);
+    // });
+
+    const filter = token.filters.TokenIssuableKSD(null,null);
+    token.on(filter,(isin,slipSeqKSD, event) => {
+        console.log(event);
+    });
+
+    // const abi = ['event TokenIssuableKSD(bytes32 isin, bytes32 slipSeqKSD)'];
+    // //const singer: JsonRpcSigner = await provider.getSigner();
+    // const contract = new Contract(
+    //   tokenAddress,
+    //   abi,
+    //   operator
+    // );
+    
+    // //contract.on('TokenIssuableKSD', (isin,slipSeqKSD, event) => {
+    // contract.on('TokenIssuableKSD', (data) => {
+    //   console.log(data);
+    //     // TokenIssuableKSD 에서 저장한 정보를 찾아서
+    //   //issueKSD()
+    //   });
+      
+    console.log("Listening for TokenIssuableKSD events...");
+    setInterval(() => {}, 1000);
+  }
+
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000200 (토큰증권 테스트 종목20) -> 0x9D084404B8558604a1e69B9782A6f421870bd907
+
+const accountSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountSelf = '000002000001';
+const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountCustomer = '000002000002';
+
+async function main() {
+
+    //,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+    // 종목16
+    let tokenAddress = '0x920c017843904A735458AA9d30779bE5FCfcF411';
+    let slipSeqKSD = '0000000001';
+    const Symbol1 = 'KR5STO000166';
+    let qty = 1000000000;
+   
+    let rsnCode = '203';
+
+    listenIssuable(tokenAddress,admin).catch((error) => {
+        console.log(error);
+    });
+    
+
+}
+
+main();
+
+

KSD01/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+
+function toBytes32(data: string): BytesLike {
+    return hexlify(zeroPadValue(toUtf8Bytes(data), 32));
+}
+  
+/**
+ * Converts solidity byte32 to utf8 string
+ */
+function bytes32ToString(data: BytesLike): string {
+return toUtf8String(stripZerosLeft(data));
+}
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+async function issueKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+) {    
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    const decimals = await token.decimals();
+    console.log(decimals);
+    const symbol = await token.symbol();
+    console.log(symbol);
+
+    let r = await token.issueKSD(toBytes32(isin),account,KSDAccount,qty,toBytes32(slipSeqKSD));
+    // const receipt1 = await r.wait();
+    // console.log(receipt1.hash);
+}
+
+
+async function disposalLimitSetupKSD(address: string, operator: Wallet
+    ,isin: string, 
+    account: string, KSDAccount: string, rsnCode: string, qty: number
+)  {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.disposalLimitSetupKSD(toBytes32(isin),account,KSDAccount,toBytes32(rsnCode),qty);
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+
+}
+
+//function erasureKSD(bytes32 isin, address account, bytes32 KSDAccount, uint256 qty, bytes32 rsnCode, bytes32 slipSeqKSD) external;
+async function erasureKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, rsnCode: string, slipSeqKSD: string
+) {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.erasureKSD(toBytes32(isin),account,KSDAccount,qty,toBytes32(rsnCode),slipSeqKSD);
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000200 (토큰증권 테스트 종목20) -> 0x9D084404B8558604a1e69B9782A6f421870bd907
+
+const accountSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountSelf = '000002000001';
+const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountCustomer = '000002000002';
+
+async function main() {
+
+    //,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+    // 종목16
+    let tokenAddress = '0x920c017843904A735458AA9d30779bE5FCfcF411';
+    let slipSeqKSD = '0000000001';
+    const Symbol1 = 'KR5STO000166';
+    let qty = 1000000000;
+    await issueKSD(tokenAddress,admin,
+        Symbol1,
+        accountCustomer,
+        ksdAccountCustomer,
+        qty,
+        slipSeqKSD
+    );
+
+    await balanceOf(tokenAddress,admin,Symbol1,accountCustomer);
+
+    qty = 1000000000;
+    let rsnCode = '203';
+    // ,isin: string, account: string, KSDAccount: string, rsnCode: string, qty: number
+    // await disposalLimitSetupKSD(tokenAddress,admin,
+    //     Symbol1,
+    //     accountCustomer,
+    //     ksdAccountCustomer,
+    //     rsnCode,
+    //     qty
+    // );
+
+    rsnCode = '203';
+    // ,isin: string, account: string, KSDAccount: string, qty: number, rsnCode: string, slipSeqKSD: string
+    // await erasureKSD(tokenAddress,admin,
+    //     Symbol1,
+    //     accountCustomer,
+    //     ksdAccountCustomer,
+    //     qty,
+    //     rsnCode,
+    //     slipSeqKSD
+    // );
+
+
+}
+
+main();
+
+

typechain2/@openzeppelin/contracts-upgradeable/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as proxy from "./proxy";
+export type { proxy };

typechain2/@openzeppelin/contracts-upgradeable/proxy/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as utils from "./utils";
+export type { utils };

typechain2/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../../../../common";
+
+export interface InitializableInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Initializable extends BaseContract {
+  connect(runner?: ContractRunner | null): Initializable;
+  waitForDeployment(): Promise<this>;
+
+  interface: InitializableInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { Initializable } from "./Initializable";

typechain2/@openzeppelin/contracts/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as proxy from "./proxy";
+export type { proxy };
+import type * as utils from "./utils";
+export type { utils };

typechain2/@openzeppelin/contracts/proxy/beacon/IBeacon.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../../common";
+
+export interface IBeaconInterface extends Interface {
+  getFunction(nameOrSignature: "implementation"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "implementation",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "implementation",
+    data: BytesLike
+  ): Result;
+}
+
+export interface IBeacon extends BaseContract {
+  connect(runner?: ContractRunner | null): IBeacon;
+  waitForDeployment(): Promise<this>;
+
+  interface: IBeaconInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  implementation: TypedContractMethod<[], [string], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "implementation"
+  ): TypedContractMethod<[], [string], "view">;
+
+  filters: {};
+}

typechain2/@openzeppelin/contracts/proxy/beacon/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IBeacon } from "./IBeacon";

typechain2/@openzeppelin/contracts/proxy/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as beacon from "./beacon";
+export type { beacon };

typechain2/@openzeppelin/contracts/utils/Strings.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  FunctionFragment,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+} from "../../../common";
+
+export interface StringsInterface extends Interface {}
+
+export interface Strings extends BaseContract {
+  connect(runner?: ContractRunner | null): Strings;
+  waitForDeployment(): Promise<this>;
+
+  interface: StringsInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  filters: {};
+}

typechain2/@openzeppelin/contracts/utils/cryptography/ECDSA.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  FunctionFragment,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+} from "../../../../common";
+
+export interface ECDSAInterface extends Interface {}
+
+export interface ECDSA extends BaseContract {
+  connect(runner?: ContractRunner | null): ECDSA;
+  waitForDeployment(): Promise<this>;
+
+  interface: ECDSAInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  filters: {};
+}

typechain2/@openzeppelin/contracts/utils/cryptography/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { ECDSA } from "./ECDSA";

typechain2/@openzeppelin/contracts/utils/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as cryptography from "./cryptography";
+export type { cryptography };
+import type * as math from "./math";
+export type { math };
+export type { Strings } from "./Strings";

typechain2/@openzeppelin/contracts/utils/math/Math.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  FunctionFragment,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+} from "../../../../common";
+
+export interface MathInterface extends Interface {}
+
+export interface Math extends BaseContract {
+  connect(runner?: ContractRunner | null): Math;
+  waitForDeployment(): Promise<this>;
+
+  interface: MathInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  filters: {};
+}

typechain2/@openzeppelin/contracts/utils/math/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { Math } from "./Math";

typechain2/@openzeppelin/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as contracts from "./contracts";
+export type { contracts };
+import type * as contractsUpgradeable from "./contracts-upgradeable";
+export type { contractsUpgradeable };

typechain2/common.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  FunctionFragment,
+  Typed,
+  EventFragment,
+  ContractTransaction,
+  ContractTransactionResponse,
+  DeferredTopicFilter,
+  EventLog,
+  TransactionRequest,
+  LogDescription,
+} from "ethers";
+
+export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent>
+  extends DeferredTopicFilter {}
+
+export interface TypedContractEvent<
+  InputTuple extends Array<any> = any,
+  OutputTuple extends Array<any> = any,
+  OutputObject = any
+> {
+  (...args: Partial<InputTuple>): TypedDeferredTopicFilter<
+    TypedContractEvent<InputTuple, OutputTuple, OutputObject>
+  >;
+  name: string;
+  fragment: EventFragment;
+  getFragment(...args: Partial<InputTuple>): EventFragment;
+}
+
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<
+  infer _U,
+  infer W
+>
+  ? W
+  : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<
+  infer _U,
+  infer _W,
+  infer V
+>
+  ? V
+  : never;
+
+export interface TypedEventLog<TCEvent extends TypedContractEvent>
+  extends Omit<EventLog, "args"> {
+  args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+
+export interface TypedLogDescription<TCEvent extends TypedContractEvent>
+  extends Omit<LogDescription, "args"> {
+  args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+
+export type TypedListener<TCEvent extends TypedContractEvent> = (
+  ...listenerArg: [
+    ...__TypechainAOutputTuple<TCEvent>,
+    TypedEventLog<TCEvent>,
+    ...undefined[]
+  ]
+) => void;
+
+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 StateMutability = "nonpayable" | "payable" | "view";
+
+export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
+export type NonPayableOverrides = Omit<
+  BaseOverrides,
+  "value" | "blockTag" | "enableCcipRead"
+>;
+export type PayableOverrides = Omit<
+  BaseOverrides,
+  "blockTag" | "enableCcipRead"
+>;
+export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
+export type Overrides<S extends StateMutability> = S extends "nonpayable"
+  ? NonPayableOverrides
+  : S extends "payable"
+  ? PayableOverrides
+  : ViewOverrides;
+
+export type PostfixOverrides<A extends Array<any>, S extends StateMutability> =
+  | A
+  | [...A, Overrides<S>];
+export type ContractMethodArgs<
+  A extends Array<any>,
+  S extends StateMutability
+> = PostfixOverrides<{ [I in keyof A]-?: A[I] | Typed }, S>;
+
+export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+
+// export interface ContractMethod<A extends Array<any> = Array<any>, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> {
+export interface TypedContractMethod<
+  A extends Array<any> = Array<any>,
+  R = any,
+  S extends StateMutability = "payable"
+> {
+  (...args: ContractMethodArgs<A, S>): S extends "view"
+    ? Promise<DefaultReturnType<R>>
+    : Promise<ContractTransactionResponse>;
+
+  name: string;
+
+  fragment: FunctionFragment;
+
+  getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+
+  populateTransaction(
+    ...args: ContractMethodArgs<A, S>
+  ): Promise<ContractTransaction>;
+  staticCall(
+    ...args: ContractMethodArgs<A, "view">
+  ): Promise<DefaultReturnType<R>>;
+  send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+  estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+  staticCallResult(...args: ContractMethodArgs<A, "view">): Promise<R>;
+}

typechain2/contracts/Connector.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export interface ConnectorInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "admins"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "getTarget"
+      | "getTargetImplementation"
+      | "grantRole"
+      | "hasRole"
+      | "isAdmin"
+      | "revokeRole"
+      | "setTarget"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "getTarget", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getTargetImplementation",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setTarget",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getTarget", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getTargetImplementation",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "setTarget", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Connector extends BaseContract {
+  connect(runner?: ContractRunner | null): Connector;
+  waitForDeployment(): Promise<this>;
+
+  interface: ConnectorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getTarget: TypedContractMethod<[], [string], "view">;
+
+  getTargetImplementation: TypedContractMethod<[], [string], "view">;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setTarget: TypedContractMethod<[target: AddressLike], [void], "nonpayable">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getTarget"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getTargetImplementation"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setTarget"
+  ): TypedContractMethod<[target: AddressLike], [void], "nonpayable">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/Depository.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../common";
+
+export interface DepositoryInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Depository extends BaseContract {
+  connect(runner?: ContractRunner | null): Depository;
+  waitForDeployment(): Promise<this>;
+
+  interface: DepositoryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/ERC1643.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface ERC1643Interface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "CONTROLLER_ROLE"
+      | "ISSUER_ROLE"
+      | "controllers"
+      | "getAllDocuments"
+      | "getDocument"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isController"
+      | "isIssuer"
+      | "issuers"
+      | "numOfControllers"
+      | "removeDocument"
+      | "setDocument"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "DocumentRemoved"
+      | "DocumentUpdated"
+      | "Initialized"
+      | "RoleGranted"
+      | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "CONTROLLER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "ISSUER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "controllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAllDocuments",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDocument",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isController",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isIssuer",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "issuers", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "numOfControllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeDocument",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setDocument",
+    values: [BytesLike, string, string, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "CONTROLLER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "ISSUER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "controllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getAllDocuments",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDocument",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "isIssuer", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "issuers", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "numOfControllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeDocument",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setDocument",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace DocumentRemovedEvent {
+  export type InputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: BytesLike
+  ];
+  export type OutputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: string
+  ];
+  export interface OutputObject {
+    _name: string;
+    _uri: string;
+    _documentHash: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace DocumentUpdatedEvent {
+  export type InputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: BytesLike
+  ];
+  export type OutputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: string
+  ];
+  export interface OutputObject {
+    _name: string;
+    _uri: string;
+    _documentHash: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface ERC1643 extends BaseContract {
+  connect(runner?: ContractRunner | null): ERC1643;
+  waitForDeployment(): Promise<this>;
+
+  interface: ERC1643Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  CONTROLLER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  ISSUER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  controllers: TypedContractMethod<[], [string[]], "view">;
+
+  getAllDocuments: TypedContractMethod<[], [string[]], "view">;
+
+  getDocument: TypedContractMethod<
+    [nameHash: BytesLike],
+    [[string, string, string, bigint]],
+    "view"
+  >;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isController: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isIssuer: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  issuers: TypedContractMethod<[], [string[]], "view">;
+
+  numOfControllers: TypedContractMethod<[], [bigint], "view">;
+
+  removeDocument: TypedContractMethod<
+    [nameHash: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setDocument: TypedContractMethod<
+    [nameHash: BytesLike, name: string, uri: string, documentHash: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "CONTROLLER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "ISSUER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "controllers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getAllDocuments"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getDocument"
+  ): TypedContractMethod<
+    [nameHash: BytesLike],
+    [[string, string, string, bigint]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isController"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isIssuer"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issuers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "numOfControllers"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "removeDocument"
+  ): TypedContractMethod<[nameHash: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setDocument"
+  ): TypedContractMethod<
+    [nameHash: BytesLike, name: string, uri: string, documentHash: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "DocumentRemoved"
+  ): TypedContractEvent<
+    DocumentRemovedEvent.InputTuple,
+    DocumentRemovedEvent.OutputTuple,
+    DocumentRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "DocumentUpdated"
+  ): TypedContractEvent<
+    DocumentUpdatedEvent.InputTuple,
+    DocumentUpdatedEvent.OutputTuple,
+    DocumentUpdatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "DocumentRemoved(string,string,bytes32)": TypedContractEvent<
+      DocumentRemovedEvent.InputTuple,
+      DocumentRemovedEvent.OutputTuple,
+      DocumentRemovedEvent.OutputObject
+    >;
+    DocumentRemoved: TypedContractEvent<
+      DocumentRemovedEvent.InputTuple,
+      DocumentRemovedEvent.OutputTuple,
+      DocumentRemovedEvent.OutputObject
+    >;
+
+    "DocumentUpdated(string,string,bytes32)": TypedContractEvent<
+      DocumentUpdatedEvent.InputTuple,
+      DocumentUpdatedEvent.OutputTuple,
+      DocumentUpdatedEvent.OutputObject
+    >;
+    DocumentUpdated: TypedContractEvent<
+      DocumentUpdatedEvent.InputTuple,
+      DocumentUpdatedEvent.OutputTuple,
+      DocumentUpdatedEvent.OutputObject
+    >;
+
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/ERC20.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface ERC20Interface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ISSUER_ROLE"
+      | "balanceOf"
+      | "decimals"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isIssuer"
+      | "isin"
+      | "issuers"
+      | "maxSupply"
+      | "name"
+      | "symbol"
+      | "totalSupply"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "RoleGranted"
+      | "RoleRevoked"
+      | "Transfer"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ISSUER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isIssuer",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "isin", values?: undefined): string;
+  encodeFunctionData(functionFragment: "issuers", values?: undefined): string;
+  encodeFunctionData(functionFragment: "maxSupply", values?: undefined): string;
+  encodeFunctionData(functionFragment: "name", values?: undefined): string;
+  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "ISSUER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isIssuer", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isin", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "issuers", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "maxSupply", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupply",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TransferEvent {
+  export type InputTuple = [
+    from: AddressLike,
+    to: AddressLike,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [from: string, to: string, value: bigint];
+  export interface OutputObject {
+    from: string;
+    to: string;
+    value: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface ERC20 extends BaseContract {
+  connect(runner?: ContractRunner | null): ERC20;
+  waitForDeployment(): Promise<this>;
+
+  interface: ERC20Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ISSUER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  balanceOf: TypedContractMethod<[tokenHolder: AddressLike], [bigint], "view">;
+
+  decimals: TypedContractMethod<[], [bigint], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isIssuer: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isin: TypedContractMethod<[], [string], "view">;
+
+  issuers: TypedContractMethod<[], [string[]], "view">;
+
+  maxSupply: TypedContractMethod<[], [bigint], "view">;
+
+  name: TypedContractMethod<[], [string], "view">;
+
+  symbol: TypedContractMethod<[], [string], "view">;
+
+  totalSupply: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ISSUER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "balanceOf"
+  ): TypedContractMethod<[tokenHolder: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "decimals"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isIssuer"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isin"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "issuers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "maxSupply"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "name"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "symbol"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "totalSupply"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Transfer"
+  ): TypedContractEvent<
+    TransferEvent.InputTuple,
+    TransferEvent.OutputTuple,
+    TransferEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+
+    "Transfer(address,address,uint256)": TypedContractEvent<
+      TransferEvent.InputTuple,
+      TransferEvent.OutputTuple,
+      TransferEvent.OutputObject
+    >;
+    Transfer: TypedContractEvent<
+      TransferEvent.InputTuple,
+      TransferEvent.OutputTuple,
+      TransferEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/IERC1410.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IERC1410Interface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "authorizeOperator"
+      | "availableBalanceByPartition"
+      | "balanceOfByPartition"
+      | "isTokenHolderKYC"
+      | "issueByPartition"
+      | "operatorRedeemByPartition"
+      | "operatorTransferByPartition"
+      | "partitionsOf"
+      | "revokeOperator"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "AuthorizedOperator"
+      | "IssuedByPartition"
+      | "RedeemedByPartition"
+      | "RevokedOperator"
+      | "TransferByPartition"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "authorizeOperator",
+    values: [AddressLike, AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "availableBalanceByPartition",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOfByPartition",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isTokenHolderKYC",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "issueByPartition",
+    values: [BytesLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "operatorRedeemByPartition",
+    values: [BytesLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "operatorTransferByPartition",
+    values: [
+      BytesLike,
+      AddressLike,
+      AddressLike,
+      BigNumberish,
+      BytesLike,
+      BytesLike
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "partitionsOf",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeOperator",
+    values: [AddressLike, AddressLike[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "authorizeOperator",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "availableBalanceByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "balanceOfByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isTokenHolderKYC",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "issueByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "operatorRedeemByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "operatorTransferByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "partitionsOf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "revokeOperator",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace AuthorizedOperatorEvent {
+  export type InputTuple = [operator: AddressLike, tokenHolder: AddressLike];
+  export type OutputTuple = [operator: string, tokenHolder: string];
+  export interface OutputObject {
+    operator: string;
+    tokenHolder: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace IssuedByPartitionEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    operator: AddressLike,
+    to: AddressLike,
+    amount: BigNumberish,
+    data: BytesLike,
+    operatorData: BytesLike
+  ];
+  export type OutputTuple = [
+    partition: string,
+    operator: string,
+    to: string,
+    amount: bigint,
+    data: string,
+    operatorData: string
+  ];
+  export interface OutputObject {
+    partition: string;
+    operator: string;
+    to: string;
+    amount: bigint;
+    data: string;
+    operatorData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RedeemedByPartitionEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    operator: AddressLike,
+    from: AddressLike,
+    value: BigNumberish,
+    operatorData: BytesLike
+  ];
+  export type OutputTuple = [
+    partition: string,
+    operator: string,
+    from: string,
+    value: bigint,
+    operatorData: string
+  ];
+  export interface OutputObject {
+    partition: string;
+    operator: string;
+    from: string;
+    value: bigint;
+    operatorData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RevokedOperatorEvent {
+  export type InputTuple = [operator: AddressLike, tokenHolder: AddressLike];
+  export type OutputTuple = [operator: string, tokenHolder: string];
+  export interface OutputObject {
+    operator: string;
+    tokenHolder: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TransferByPartitionEvent {
+  export type InputTuple = [
+    _fromPartition: BytesLike,
+    _toPartition: BytesLike,
+    _operator: AddressLike,
+    _from: AddressLike,
+    _to: AddressLike,
+    _value: BigNumberish,
+    _data: BytesLike,
+    _operatorData: BytesLike
+  ];
+  export type OutputTuple = [
+    _fromPartition: string,
+    _toPartition: string,
+    _operator: string,
+    _from: string,
+    _to: string,
+    _value: bigint,
+    _data: string,
+    _operatorData: string
+  ];
+  export interface OutputObject {
+    _fromPartition: string;
+    _toPartition: string;
+    _operator: string;
+    _from: string;
+    _to: string;
+    _value: bigint;
+    _data: string;
+    _operatorData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface IERC1410 extends BaseContract {
+  connect(runner?: ContractRunner | null): IERC1410;
+  waitForDeployment(): Promise<this>;
+
+  interface: IERC1410Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  authorizeOperator: TypedContractMethod<
+    [_operator: AddressLike, tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  availableBalanceByPartition: TypedContractMethod<
+    [from: AddressLike, partition: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  balanceOfByPartition: TypedContractMethod<
+    [_partition: BytesLike, _tokenHolder: AddressLike],
+    [bigint],
+    "view"
+  >;
+
+  isTokenHolderKYC: TypedContractMethod<
+    [tokenHolder: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  issueByPartition: TypedContractMethod<
+    [
+      _partition: BytesLike,
+      _tokenHolder: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  operatorRedeemByPartition: TypedContractMethod<
+    [
+      _partition: BytesLike,
+      _tokenHolder: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  operatorTransferByPartition: TypedContractMethod<
+    [
+      _partition: BytesLike,
+      _from: AddressLike,
+      _to: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike,
+      _operatorData: BytesLike
+    ],
+    [string],
+    "nonpayable"
+  >;
+
+  partitionsOf: TypedContractMethod<
+    [_tokenHolder: AddressLike],
+    [string[]],
+    "view"
+  >;
+
+  revokeOperator: TypedContractMethod<
+    [_operator: AddressLike, tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "authorizeOperator"
+  ): TypedContractMethod<
+    [_operator: AddressLike, tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "availableBalanceByPartition"
+  ): TypedContractMethod<
+    [from: AddressLike, partition: BytesLike],
+    [bigint],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "balanceOfByPartition"
+  ): TypedContractMethod<
+    [_partition: BytesLike, _tokenHolder: AddressLike],
+    [bigint],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isTokenHolderKYC"
+  ): TypedContractMethod<[tokenHolder: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issueByPartition"
+  ): TypedContractMethod<
+    [
+      _partition: BytesLike,
+      _tokenHolder: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "operatorRedeemByPartition"
+  ): TypedContractMethod<
+    [
+      _partition: BytesLike,
+      _tokenHolder: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "operatorTransferByPartition"
+  ): TypedContractMethod<
+    [
+      _partition: BytesLike,
+      _from: AddressLike,
+      _to: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike,
+      _operatorData: BytesLike
+    ],
+    [string],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "partitionsOf"
+  ): TypedContractMethod<[_tokenHolder: AddressLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "revokeOperator"
+  ): TypedContractMethod<
+    [_operator: AddressLike, tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "AuthorizedOperator"
+  ): TypedContractEvent<
+    AuthorizedOperatorEvent.InputTuple,
+    AuthorizedOperatorEvent.OutputTuple,
+    AuthorizedOperatorEvent.OutputObject
+  >;
+  getEvent(
+    key: "IssuedByPartition"
+  ): TypedContractEvent<
+    IssuedByPartitionEvent.InputTuple,
+    IssuedByPartitionEvent.OutputTuple,
+    IssuedByPartitionEvent.OutputObject
+  >;
+  getEvent(
+    key: "RedeemedByPartition"
+  ): TypedContractEvent<
+    RedeemedByPartitionEvent.InputTuple,
+    RedeemedByPartitionEvent.OutputTuple,
+    RedeemedByPartitionEvent.OutputObject
+  >;
+  getEvent(
+    key: "RevokedOperator"
+  ): TypedContractEvent<
+    RevokedOperatorEvent.InputTuple,
+    RevokedOperatorEvent.OutputTuple,
+    RevokedOperatorEvent.OutputObject
+  >;
+  getEvent(
+    key: "TransferByPartition"
+  ): TypedContractEvent<
+    TransferByPartitionEvent.InputTuple,
+    TransferByPartitionEvent.OutputTuple,
+    TransferByPartitionEvent.OutputObject
+  >;
+
+  filters: {
+    "AuthorizedOperator(address,address)": TypedContractEvent<
+      AuthorizedOperatorEvent.InputTuple,
+      AuthorizedOperatorEvent.OutputTuple,
+      AuthorizedOperatorEvent.OutputObject
+    >;
+    AuthorizedOperator: TypedContractEvent<
+      AuthorizedOperatorEvent.InputTuple,
+      AuthorizedOperatorEvent.OutputTuple,
+      AuthorizedOperatorEvent.OutputObject
+    >;
+
+    "IssuedByPartition(bytes32,address,address,uint256,bytes,bytes)": TypedContractEvent<
+      IssuedByPartitionEvent.InputTuple,
+      IssuedByPartitionEvent.OutputTuple,
+      IssuedByPartitionEvent.OutputObject
+    >;
+    IssuedByPartition: TypedContractEvent<
+      IssuedByPartitionEvent.InputTuple,
+      IssuedByPartitionEvent.OutputTuple,
+      IssuedByPartitionEvent.OutputObject
+    >;
+
+    "RedeemedByPartition(bytes32,address,address,uint256,bytes)": TypedContractEvent<
+      RedeemedByPartitionEvent.InputTuple,
+      RedeemedByPartitionEvent.OutputTuple,
+      RedeemedByPartitionEvent.OutputObject
+    >;
+    RedeemedByPartition: TypedContractEvent<
+      RedeemedByPartitionEvent.InputTuple,
+      RedeemedByPartitionEvent.OutputTuple,
+      RedeemedByPartitionEvent.OutputObject
+    >;
+
+    "RevokedOperator(address,address)": TypedContractEvent<
+      RevokedOperatorEvent.InputTuple,
+      RevokedOperatorEvent.OutputTuple,
+      RevokedOperatorEvent.OutputObject
+    >;
+    RevokedOperator: TypedContractEvent<
+      RevokedOperatorEvent.InputTuple,
+      RevokedOperatorEvent.OutputTuple,
+      RevokedOperatorEvent.OutputObject
+    >;
+
+    "TransferByPartition(bytes32,bytes32,address,address,address,uint256,bytes,bytes)": TypedContractEvent<
+      TransferByPartitionEvent.InputTuple,
+      TransferByPartitionEvent.OutputTuple,
+      TransferByPartitionEvent.OutputObject
+    >;
+    TransferByPartition: TypedContractEvent<
+      TransferByPartitionEvent.InputTuple,
+      TransferByPartitionEvent.OutputTuple,
+      TransferByPartitionEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/IERC1594.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IERC1594Interface extends Interface {
+  getFunction(
+    nameOrSignature: "isIssuable" | "issue" | "redeemFrom"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "IssuanceRenunciation" | "Issued" | "Redeemed"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "isIssuable",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "issue",
+    values: [AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemFrom",
+    values: [AddressLike, BigNumberish, BytesLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "isIssuable", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "issue", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "redeemFrom", data: BytesLike): Result;
+}
+
+export namespace IssuanceRenunciationEvent {
+  export type InputTuple = [issuer: AddressLike];
+  export type OutputTuple = [issuer: string];
+  export interface OutputObject {
+    issuer: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace IssuedEvent {
+  export type InputTuple = [
+    _operator: AddressLike,
+    _to: AddressLike,
+    _value: BigNumberish,
+    _data: BytesLike
+  ];
+  export type OutputTuple = [
+    _operator: string,
+    _to: string,
+    _value: bigint,
+    _data: string
+  ];
+  export interface OutputObject {
+    _operator: string;
+    _to: string;
+    _value: bigint;
+    _data: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RedeemedEvent {
+  export type InputTuple = [
+    _operator: AddressLike,
+    _from: AddressLike,
+    _value: BigNumberish,
+    _data: BytesLike
+  ];
+  export type OutputTuple = [
+    _operator: string,
+    _from: string,
+    _value: bigint,
+    _data: string
+  ];
+  export interface OutputObject {
+    _operator: string;
+    _from: string;
+    _value: bigint;
+    _data: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface IERC1594 extends BaseContract {
+  connect(runner?: ContractRunner | null): IERC1594;
+  waitForDeployment(): Promise<this>;
+
+  interface: IERC1594Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  isIssuable: TypedContractMethod<[], [boolean], "view">;
+
+  issue: TypedContractMethod<
+    [_tokenHolder: AddressLike, _value: BigNumberish, _data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  redeemFrom: TypedContractMethod<
+    [_tokenHolder: AddressLike, _value: BigNumberish, _data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "isIssuable"
+  ): TypedContractMethod<[], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issue"
+  ): TypedContractMethod<
+    [_tokenHolder: AddressLike, _value: BigNumberish, _data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "redeemFrom"
+  ): TypedContractMethod<
+    [_tokenHolder: AddressLike, _value: BigNumberish, _data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "IssuanceRenunciation"
+  ): TypedContractEvent<
+    IssuanceRenunciationEvent.InputTuple,
+    IssuanceRenunciationEvent.OutputTuple,
+    IssuanceRenunciationEvent.OutputObject
+  >;
+  getEvent(
+    key: "Issued"
+  ): TypedContractEvent<
+    IssuedEvent.InputTuple,
+    IssuedEvent.OutputTuple,
+    IssuedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Redeemed"
+  ): TypedContractEvent<
+    RedeemedEvent.InputTuple,
+    RedeemedEvent.OutputTuple,
+    RedeemedEvent.OutputObject
+  >;
+
+  filters: {
+    "IssuanceRenunciation(address)": TypedContractEvent<
+      IssuanceRenunciationEvent.InputTuple,
+      IssuanceRenunciationEvent.OutputTuple,
+      IssuanceRenunciationEvent.OutputObject
+    >;
+    IssuanceRenunciation: TypedContractEvent<
+      IssuanceRenunciationEvent.InputTuple,
+      IssuanceRenunciationEvent.OutputTuple,
+      IssuanceRenunciationEvent.OutputObject
+    >;
+
+    "Issued(address,address,uint256,bytes)": TypedContractEvent<
+      IssuedEvent.InputTuple,
+      IssuedEvent.OutputTuple,
+      IssuedEvent.OutputObject
+    >;
+    Issued: TypedContractEvent<
+      IssuedEvent.InputTuple,
+      IssuedEvent.OutputTuple,
+      IssuedEvent.OutputObject
+    >;
+
+    "Redeemed(address,address,uint256,bytes)": TypedContractEvent<
+      RedeemedEvent.InputTuple,
+      RedeemedEvent.OutputTuple,
+      RedeemedEvent.OutputObject
+    >;
+    Redeemed: TypedContractEvent<
+      RedeemedEvent.InputTuple,
+      RedeemedEvent.OutputTuple,
+      RedeemedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/IERC1643.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IERC1643Interface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "getAllDocuments"
+      | "getDocument"
+      | "removeDocument"
+      | "setDocument"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "DocumentRemoved" | "DocumentUpdated"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "getAllDocuments",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDocument",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeDocument",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setDocument",
+    values: [BytesLike, string, string, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getAllDocuments",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDocument",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeDocument",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setDocument",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace DocumentRemovedEvent {
+  export type InputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: BytesLike
+  ];
+  export type OutputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: string
+  ];
+  export interface OutputObject {
+    _name: string;
+    _uri: string;
+    _documentHash: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace DocumentUpdatedEvent {
+  export type InputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: BytesLike
+  ];
+  export type OutputTuple = [
+    _name: string,
+    _uri: string,
+    _documentHash: string
+  ];
+  export interface OutputObject {
+    _name: string;
+    _uri: string;
+    _documentHash: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface IERC1643 extends BaseContract {
+  connect(runner?: ContractRunner | null): IERC1643;
+  waitForDeployment(): Promise<this>;
+
+  interface: IERC1643Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getAllDocuments: TypedContractMethod<[], [string[]], "view">;
+
+  getDocument: TypedContractMethod<
+    [_nameHash: BytesLike],
+    [[string, string, string, bigint]],
+    "view"
+  >;
+
+  removeDocument: TypedContractMethod<
+    [_nameHash: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setDocument: TypedContractMethod<
+    [
+      _nameHash: BytesLike,
+      name: string,
+      _uri: string,
+      _documentHash: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getAllDocuments"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getDocument"
+  ): TypedContractMethod<
+    [_nameHash: BytesLike],
+    [[string, string, string, bigint]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "removeDocument"
+  ): TypedContractMethod<[_nameHash: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setDocument"
+  ): TypedContractMethod<
+    [
+      _nameHash: BytesLike,
+      name: string,
+      _uri: string,
+      _documentHash: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "DocumentRemoved"
+  ): TypedContractEvent<
+    DocumentRemovedEvent.InputTuple,
+    DocumentRemovedEvent.OutputTuple,
+    DocumentRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "DocumentUpdated"
+  ): TypedContractEvent<
+    DocumentUpdatedEvent.InputTuple,
+    DocumentUpdatedEvent.OutputTuple,
+    DocumentUpdatedEvent.OutputObject
+  >;
+
+  filters: {
+    "DocumentRemoved(string,string,bytes32)": TypedContractEvent<
+      DocumentRemovedEvent.InputTuple,
+      DocumentRemovedEvent.OutputTuple,
+      DocumentRemovedEvent.OutputObject
+    >;
+    DocumentRemoved: TypedContractEvent<
+      DocumentRemovedEvent.InputTuple,
+      DocumentRemovedEvent.OutputTuple,
+      DocumentRemovedEvent.OutputObject
+    >;
+
+    "DocumentUpdated(string,string,bytes32)": TypedContractEvent<
+      DocumentUpdatedEvent.InputTuple,
+      DocumentUpdatedEvent.OutputTuple,
+      DocumentUpdatedEvent.OutputObject
+    >;
+    DocumentUpdated: TypedContractEvent<
+      DocumentUpdatedEvent.InputTuple,
+      DocumentUpdatedEvent.OutputTuple,
+      DocumentUpdatedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/IERC1644.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IERC1644Interface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "controllerRedeem"
+      | "controllerTransfer"
+      | "isControllable"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "ControllerRedemption"
+      | "ControllerRedemptionByPartition"
+      | "ControllerTransfer"
+      | "ControllerTransferByPartition"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "controllerRedeem",
+    values: [AddressLike, BigNumberish, BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "controllerTransfer",
+    values: [AddressLike, AddressLike, BigNumberish, BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isControllable",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "controllerRedeem",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "controllerTransfer",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isControllable",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace ControllerRedemptionEvent {
+  export type InputTuple = [
+    _controller: AddressLike,
+    _tokenHolder: AddressLike,
+    _value: BigNumberish,
+    _data: BytesLike,
+    _operatorData: BytesLike
+  ];
+  export type OutputTuple = [
+    _controller: string,
+    _tokenHolder: string,
+    _value: bigint,
+    _data: string,
+    _operatorData: string
+  ];
+  export interface OutputObject {
+    _controller: string;
+    _tokenHolder: string;
+    _value: bigint;
+    _data: string;
+    _operatorData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ControllerRedemptionByPartitionEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    controller: AddressLike,
+    tokenHolder: AddressLike,
+    value: BigNumberish,
+    data: BytesLike,
+    controllerData: BytesLike
+  ];
+  export type OutputTuple = [
+    partition: string,
+    controller: string,
+    tokenHolder: string,
+    value: bigint,
+    data: string,
+    controllerData: string
+  ];
+  export interface OutputObject {
+    partition: string;
+    controller: string;
+    tokenHolder: string;
+    value: bigint;
+    data: string;
+    controllerData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ControllerTransferEvent {
+  export type InputTuple = [
+    _controller: AddressLike,
+    _from: AddressLike,
+    _to: AddressLike,
+    _value: BigNumberish,
+    _data: BytesLike,
+    _operatorData: BytesLike
+  ];
+  export type OutputTuple = [
+    _controller: string,
+    _from: string,
+    _to: string,
+    _value: bigint,
+    _data: string,
+    _operatorData: string
+  ];
+  export interface OutputObject {
+    _controller: string;
+    _from: string;
+    _to: string;
+    _value: bigint;
+    _data: string;
+    _operatorData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ControllerTransferByPartitionEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    controller: AddressLike,
+    from: AddressLike,
+    to: AddressLike,
+    value: BigNumberish,
+    data: BytesLike,
+    controllerData: BytesLike
+  ];
+  export type OutputTuple = [
+    partition: string,
+    controller: string,
+    from: string,
+    to: string,
+    value: bigint,
+    data: string,
+    controllerData: string
+  ];
+  export interface OutputObject {
+    partition: string;
+    controller: string;
+    from: string;
+    to: string;
+    value: bigint;
+    data: string;
+    controllerData: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface IERC1644 extends BaseContract {
+  connect(runner?: ContractRunner | null): IERC1644;
+  waitForDeployment(): Promise<this>;
+
+  interface: IERC1644Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  controllerRedeem: TypedContractMethod<
+    [
+      _tokenHolder: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike,
+      _operatorData: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  controllerTransfer: TypedContractMethod<
+    [
+      _from: AddressLike,
+      _to: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike,
+      _operatorData: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  isControllable: TypedContractMethod<[], [boolean], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "controllerRedeem"
+  ): TypedContractMethod<
+    [
+      _tokenHolder: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike,
+      _operatorData: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "controllerTransfer"
+  ): TypedContractMethod<
+    [
+      _from: AddressLike,
+      _to: AddressLike,
+      _value: BigNumberish,
+      _data: BytesLike,
+      _operatorData: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "isControllable"
+  ): TypedContractMethod<[], [boolean], "view">;
+
+  getEvent(
+    key: "ControllerRedemption"
+  ): TypedContractEvent<
+    ControllerRedemptionEvent.InputTuple,
+    ControllerRedemptionEvent.OutputTuple,
+    ControllerRedemptionEvent.OutputObject
+  >;
+  getEvent(
+    key: "ControllerRedemptionByPartition"
+  ): TypedContractEvent<
+    ControllerRedemptionByPartitionEvent.InputTuple,
+    ControllerRedemptionByPartitionEvent.OutputTuple,
+    ControllerRedemptionByPartitionEvent.OutputObject
+  >;
+  getEvent(
+    key: "ControllerTransfer"
+  ): TypedContractEvent<
+    ControllerTransferEvent.InputTuple,
+    ControllerTransferEvent.OutputTuple,
+    ControllerTransferEvent.OutputObject
+  >;
+  getEvent(
+    key: "ControllerTransferByPartition"
+  ): TypedContractEvent<
+    ControllerTransferByPartitionEvent.InputTuple,
+    ControllerTransferByPartitionEvent.OutputTuple,
+    ControllerTransferByPartitionEvent.OutputObject
+  >;
+
+  filters: {
+    "ControllerRedemption(address,address,uint256,bytes,bytes)": TypedContractEvent<
+      ControllerRedemptionEvent.InputTuple,
+      ControllerRedemptionEvent.OutputTuple,
+      ControllerRedemptionEvent.OutputObject
+    >;
+    ControllerRedemption: TypedContractEvent<
+      ControllerRedemptionEvent.InputTuple,
+      ControllerRedemptionEvent.OutputTuple,
+      ControllerRedemptionEvent.OutputObject
+    >;
+
+    "ControllerRedemptionByPartition(bytes32,address,address,uint256,bytes,bytes)": TypedContractEvent<
+      ControllerRedemptionByPartitionEvent.InputTuple,
+      ControllerRedemptionByPartitionEvent.OutputTuple,
+      ControllerRedemptionByPartitionEvent.OutputObject
+    >;
+    ControllerRedemptionByPartition: TypedContractEvent<
+      ControllerRedemptionByPartitionEvent.InputTuple,
+      ControllerRedemptionByPartitionEvent.OutputTuple,
+      ControllerRedemptionByPartitionEvent.OutputObject
+    >;
+
+    "ControllerTransfer(address,address,address,uint256,bytes,bytes)": TypedContractEvent<
+      ControllerTransferEvent.InputTuple,
+      ControllerTransferEvent.OutputTuple,
+      ControllerTransferEvent.OutputObject
+    >;
+    ControllerTransfer: TypedContractEvent<
+      ControllerTransferEvent.InputTuple,
+      ControllerTransferEvent.OutputTuple,
+      ControllerTransferEvent.OutputObject
+    >;
+
+    "ControllerTransferByPartition(bytes32,address,address,address,uint256,bytes,bytes)": TypedContractEvent<
+      ControllerTransferByPartitionEvent.InputTuple,
+      ControllerTransferByPartitionEvent.OutputTuple,
+      ControllerTransferByPartitionEvent.OutputObject
+    >;
+    ControllerTransferByPartition: TypedContractEvent<
+      ControllerTransferByPartitionEvent.InputTuple,
+      ControllerTransferByPartitionEvent.OutputTuple,
+      ControllerTransferByPartitionEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/IERC20.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IERC20Interface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "balanceOf"
+      | "decimals"
+      | "isin"
+      | "maxSupply"
+      | "name"
+      | "symbol"
+      | "totalSupply"
+  ): FunctionFragment;
+
+  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+  encodeFunctionData(functionFragment: "isin", values?: undefined): string;
+  encodeFunctionData(functionFragment: "maxSupply", values?: undefined): string;
+  encodeFunctionData(functionFragment: "name", values?: undefined): string;
+  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "totalSupply",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isin", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "maxSupply", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupply",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace TransferEvent {
+  export type InputTuple = [
+    from: AddressLike,
+    to: AddressLike,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [from: string, to: string, value: bigint];
+  export interface OutputObject {
+    from: string;
+    to: string;
+    value: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface IERC20 extends BaseContract {
+  connect(runner?: ContractRunner | null): IERC20;
+  waitForDeployment(): Promise<this>;
+
+  interface: IERC20Interface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  balanceOf: TypedContractMethod<[tokenHolder: AddressLike], [bigint], "view">;
+
+  decimals: TypedContractMethod<[], [bigint], "view">;
+
+  isin: TypedContractMethod<[], [string], "view">;
+
+  maxSupply: TypedContractMethod<[], [bigint], "view">;
+
+  name: TypedContractMethod<[], [string], "view">;
+
+  symbol: TypedContractMethod<[], [string], "view">;
+
+  totalSupply: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "balanceOf"
+  ): TypedContractMethod<[tokenHolder: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "decimals"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "isin"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "maxSupply"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "name"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "symbol"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "totalSupply"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "Transfer"
+  ): TypedContractEvent<
+    TransferEvent.InputTuple,
+    TransferEvent.OutputTuple,
+    TransferEvent.OutputObject
+  >;
+
+  filters: {
+    "Transfer(address,address,uint256)": TypedContractEvent<
+      TransferEvent.InputTuple,
+      TransferEvent.OutputTuple,
+      TransferEvent.OutputObject
+    >;
+    Transfer: TypedContractEvent<
+      TransferEvent.InputTuple,
+      TransferEvent.OutputTuple,
+      TransferEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ERC/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { ERC1400 } from "./ERC1400";
+export type { ERC1410 } from "./ERC1410";
+export type { ERC1594 } from "./ERC1594";
+export type { ERC1643 } from "./ERC1643";
+export type { ERC1644 } from "./ERC1644";
+export type { ERC20 } from "./ERC20";
+export type { IERC1410 } from "./IERC1410";
+export type { IERC1594 } from "./IERC1594";
+export type { IERC1643 } from "./IERC1643";
+export type { IERC1644 } from "./IERC1644";
+export type { IERC20 } from "./IERC20";

typechain2/contracts/GlobalKycRegistry.sol/GlobalKycRegistry.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface GlobalKycRegistryInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "KYCtokenHolders"
+      | "OPERATOR_ROLE"
+      | "admins"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "grantRole"
+      | "hasRole"
+      | "holderCount"
+      | "initialize"
+      | "isAdmin"
+      | "isOperator"
+      | "isTokenHolderKYC"
+      | "operators"
+      | "revokeRole"
+      | "unKYCtokenHolders"
+      | "version"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "KYCtokenHolders",
+    values: [AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "OPERATOR_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "holderCount",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isOperator",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isTokenHolderKYC",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "operators", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unKYCtokenHolders",
+    values: [AddressLike[]]
+  ): string;
+  encodeFunctionData(functionFragment: "version", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "KYCtokenHolders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "OPERATOR_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "holderCount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isTokenHolderKYC",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "operators", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "unKYCtokenHolders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface GlobalKycRegistry extends BaseContract {
+  connect(runner?: ContractRunner | null): GlobalKycRegistry;
+  waitForDeployment(): Promise<this>;
+
+  interface: GlobalKycRegistryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  KYCtokenHolders: TypedContractMethod<
+    [tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  OPERATOR_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  holderCount: TypedContractMethod<[], [bigint], "view">;
+
+  initialize: TypedContractMethod<[], [void], "nonpayable">;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isOperator: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isTokenHolderKYC: TypedContractMethod<
+    [tokenHolder: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  operators: TypedContractMethod<[], [string[]], "view">;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  unKYCtokenHolders: TypedContractMethod<
+    [tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  version: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "KYCtokenHolders"
+  ): TypedContractMethod<[tokenHolders: AddressLike[]], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "OPERATOR_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "holderCount"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isOperator"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isTokenHolderKYC"
+  ): TypedContractMethod<[tokenHolder: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "operators"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "unKYCtokenHolders"
+  ): TypedContractMethod<[tokenHolders: AddressLike[]], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "version"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/GlobalKycRegistry.sol/IGlobalKycRegistry.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IGlobalKycRegistryInterface extends Interface {
+  getFunction(nameOrSignature: "isTokenHolderKYC"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "isTokenHolderKYC",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "isTokenHolderKYC",
+    data: BytesLike
+  ): Result;
+}
+
+export interface IGlobalKycRegistry extends BaseContract {
+  connect(runner?: ContractRunner | null): IGlobalKycRegistry;
+  waitForDeployment(): Promise<this>;
+
+  interface: IGlobalKycRegistryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  isTokenHolderKYC: TypedContractMethod<
+    [tokenHolder: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "isTokenHolderKYC"
+  ): TypedContractMethod<[tokenHolder: AddressLike], [boolean], "view">;
+
+  filters: {};
+}

typechain2/contracts/GlobalKycRegistry.sol/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { GlobalKycRegistry } from "./GlobalKycRegistry";
+export type { IGlobalKycRegistry } from "./IGlobalKycRegistry";

typechain2/contracts/IProvideSelector.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export interface IProvideSelectorInterface extends Interface {
+  getFunction(nameOrSignature: "getSelectors"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getSelectors",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getSelectors",
+    data: BytesLike
+  ): Result;
+}
+
+export interface IProvideSelector extends BaseContract {
+  connect(runner?: ContractRunner | null): IProvideSelector;
+  waitForDeployment(): Promise<this>;
+
+  interface: IProvideSelectorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getSelectors: TypedContractMethod<[], [string], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getSelectors"
+  ): TypedContractMethod<[], [string], "view">;
+
+  filters: {};
+}

typechain2/contracts/ISecuritiesDepository.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export declare namespace DepositoryStorageDomain {
+  export type TokenStruct = {
+    isin: BytesLike;
+    tokenAddress: AddressLike;
+    issuableSupply: BigNumberish;
+    redeemableSupply: BigNumberish;
+    issuedSupply: BigNumberish;
+    redeemedSupply: BigNumberish;
+  };
+
+  export type TokenStructOutput = [
+    isin: string,
+    tokenAddress: string,
+    issuableSupply: bigint,
+    redeemableSupply: bigint,
+    issuedSupply: bigint,
+    redeemedSupply: bigint
+  ] & {
+    isin: string;
+    tokenAddress: string;
+    issuableSupply: bigint;
+    redeemableSupply: bigint;
+    issuedSupply: bigint;
+    redeemedSupply: bigint;
+  };
+}
+
+export interface ISecuritiesDepositoryInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "getAccountRepositories"
+      | "getAccountRepository"
+      | "getToken"
+      | "getTokens"
+      | "registerAccountRepository"
+      | "registerAccounts"
+      | "registerToken"
+      | "unregisterAccounts"
+      | "unregisterToken"
+      | "updateAccountRepositoryOwner"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "AccountRegistered"
+      | "AccountRepositoryOwnerUpdated"
+      | "AccountRepositoryRegistered"
+      | "AccountUnregistered"
+      | "TokenRegistered"
+      | "TokenUnregistered"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "getAccountRepositories",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAccountRepository",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "getToken", values: [BytesLike]): string;
+  encodeFunctionData(functionFragment: "getTokens", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "registerAccountRepository",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerAccounts",
+    values: [BytesLike, AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerToken",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unregisterAccounts",
+    values: [BytesLike, AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unregisterToken",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "updateAccountRepositoryOwner",
+    values: [BytesLike, AddressLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getAccountRepositories",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getAccountRepository",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getToken", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getTokens", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "registerAccountRepository",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerAccounts",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerToken",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "unregisterAccounts",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "unregisterToken",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "updateAccountRepositoryOwner",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace AccountRegisteredEvent {
+  export type InputTuple = [repositoryID: BytesLike, account: AddressLike];
+  export type OutputTuple = [repositoryID: string, account: string];
+  export interface OutputObject {
+    repositoryID: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace AccountRepositoryOwnerUpdatedEvent {
+  export type InputTuple = [repositoryID: BytesLike, operator: AddressLike];
+  export type OutputTuple = [repositoryID: string, operator: string];
+  export interface OutputObject {
+    repositoryID: string;
+    operator: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace AccountRepositoryRegisteredEvent {
+  export type InputTuple = [repositoryID: BytesLike];
+  export type OutputTuple = [repositoryID: string];
+  export interface OutputObject {
+    repositoryID: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace AccountUnregisteredEvent {
+  export type InputTuple = [repositoryID: BytesLike, account: AddressLike];
+  export type OutputTuple = [repositoryID: string, account: string];
+  export interface OutputObject {
+    repositoryID: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenRegisteredEvent {
+  export type InputTuple = [isin: BytesLike, token: AddressLike];
+  export type OutputTuple = [isin: string, token: string];
+  export interface OutputObject {
+    isin: string;
+    token: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenUnregisteredEvent {
+  export type InputTuple = [isin: BytesLike];
+  export type OutputTuple = [isin: string];
+  export interface OutputObject {
+    isin: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface ISecuritiesDepository extends BaseContract {
+  connect(runner?: ContractRunner | null): ISecuritiesDepository;
+  waitForDeployment(): Promise<this>;
+
+  interface: ISecuritiesDepositoryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getAccountRepositories: TypedContractMethod<[], [string[]], "view">;
+
+  getAccountRepository: TypedContractMethod<
+    [repositoryID: BytesLike],
+    [[string, bigint] & { owner: string; numOfAccounts: bigint }],
+    "view"
+  >;
+
+  getToken: TypedContractMethod<
+    [isin: BytesLike],
+    [DepositoryStorageDomain.TokenStructOutput],
+    "view"
+  >;
+
+  getTokens: TypedContractMethod<
+    [],
+    [DepositoryStorageDomain.TokenStructOutput[]],
+    "view"
+  >;
+
+  registerAccountRepository: TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  registerAccounts: TypedContractMethod<
+    [repositoryID: BytesLike, accounts: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  registerToken: TypedContractMethod<
+    [isin: BytesLike, token: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  unregisterAccounts: TypedContractMethod<
+    [repositoryID: BytesLike, accounts: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  unregisterToken: TypedContractMethod<[isin: BytesLike], [void], "nonpayable">;
+
+  updateAccountRepositoryOwner: TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getAccountRepositories"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getAccountRepository"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike],
+    [[string, bigint] & { owner: string; numOfAccounts: bigint }],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getToken"
+  ): TypedContractMethod<
+    [isin: BytesLike],
+    [DepositoryStorageDomain.TokenStructOutput],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getTokens"
+  ): TypedContractMethod<
+    [],
+    [DepositoryStorageDomain.TokenStructOutput[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "registerAccountRepository"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "registerAccounts"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, accounts: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "registerToken"
+  ): TypedContractMethod<
+    [isin: BytesLike, token: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "unregisterAccounts"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, accounts: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "unregisterToken"
+  ): TypedContractMethod<[isin: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "updateAccountRepositoryOwner"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "AccountRegistered"
+  ): TypedContractEvent<
+    AccountRegisteredEvent.InputTuple,
+    AccountRegisteredEvent.OutputTuple,
+    AccountRegisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "AccountRepositoryOwnerUpdated"
+  ): TypedContractEvent<
+    AccountRepositoryOwnerUpdatedEvent.InputTuple,
+    AccountRepositoryOwnerUpdatedEvent.OutputTuple,
+    AccountRepositoryOwnerUpdatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "AccountRepositoryRegistered"
+  ): TypedContractEvent<
+    AccountRepositoryRegisteredEvent.InputTuple,
+    AccountRepositoryRegisteredEvent.OutputTuple,
+    AccountRepositoryRegisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "AccountUnregistered"
+  ): TypedContractEvent<
+    AccountUnregisteredEvent.InputTuple,
+    AccountUnregisteredEvent.OutputTuple,
+    AccountUnregisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenRegistered"
+  ): TypedContractEvent<
+    TokenRegisteredEvent.InputTuple,
+    TokenRegisteredEvent.OutputTuple,
+    TokenRegisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenUnregistered"
+  ): TypedContractEvent<
+    TokenUnregisteredEvent.InputTuple,
+    TokenUnregisteredEvent.OutputTuple,
+    TokenUnregisteredEvent.OutputObject
+  >;
+
+  filters: {
+    "AccountRegistered(bytes32,address)": TypedContractEvent<
+      AccountRegisteredEvent.InputTuple,
+      AccountRegisteredEvent.OutputTuple,
+      AccountRegisteredEvent.OutputObject
+    >;
+    AccountRegistered: TypedContractEvent<
+      AccountRegisteredEvent.InputTuple,
+      AccountRegisteredEvent.OutputTuple,
+      AccountRegisteredEvent.OutputObject
+    >;
+
+    "AccountRepositoryOwnerUpdated(bytes32,address)": TypedContractEvent<
+      AccountRepositoryOwnerUpdatedEvent.InputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputObject
+    >;
+    AccountRepositoryOwnerUpdated: TypedContractEvent<
+      AccountRepositoryOwnerUpdatedEvent.InputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputObject
+    >;
+
+    "AccountRepositoryRegistered(bytes32)": TypedContractEvent<
+      AccountRepositoryRegisteredEvent.InputTuple,
+      AccountRepositoryRegisteredEvent.OutputTuple,
+      AccountRepositoryRegisteredEvent.OutputObject
+    >;
+    AccountRepositoryRegistered: TypedContractEvent<
+      AccountRepositoryRegisteredEvent.InputTuple,
+      AccountRepositoryRegisteredEvent.OutputTuple,
+      AccountRepositoryRegisteredEvent.OutputObject
+    >;
+
+    "AccountUnregistered(bytes32,address)": TypedContractEvent<
+      AccountUnregisteredEvent.InputTuple,
+      AccountUnregisteredEvent.OutputTuple,
+      AccountUnregisteredEvent.OutputObject
+    >;
+    AccountUnregistered: TypedContractEvent<
+      AccountUnregisteredEvent.InputTuple,
+      AccountUnregisteredEvent.OutputTuple,
+      AccountUnregisteredEvent.OutputObject
+    >;
+
+    "TokenRegistered(bytes32,address)": TypedContractEvent<
+      TokenRegisteredEvent.InputTuple,
+      TokenRegisteredEvent.OutputTuple,
+      TokenRegisteredEvent.OutputObject
+    >;
+    TokenRegistered: TypedContractEvent<
+      TokenRegisteredEvent.InputTuple,
+      TokenRegisteredEvent.OutputTuple,
+      TokenRegisteredEvent.OutputObject
+    >;
+
+    "TokenUnregistered(bytes32)": TypedContractEvent<
+      TokenUnregisteredEvent.InputTuple,
+      TokenUnregisteredEvent.OutputTuple,
+      TokenUnregisteredEvent.OutputObject
+    >;
+    TokenUnregistered: TypedContractEvent<
+      TokenUnregisteredEvent.InputTuple,
+      TokenUnregisteredEvent.OutputTuple,
+      TokenUnregisteredEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/ISecurityTokenDepository.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export interface ISecurityTokenDepositoryInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "getTokenAddress"
+      | "registerAccount"
+      | "registerAccountRepository"
+      | "registerToken"
+      | "unregisterAccount"
+      | "unregisterToken"
+      | "updateAccountRepositoryOwner"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "AccountRegistered"
+      | "AccountRepositoryOwnerUpdated"
+      | "AccountRepositoryRegistered"
+      | "AccountUnregistered"
+      | "TokenRegistered"
+      | "TokenUnregistered"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "getTokenAddress",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerAccount",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerAccountRepository",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "registerToken",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unregisterAccount",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unregisterToken",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "updateAccountRepositoryOwner",
+    values: [BytesLike, AddressLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getTokenAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerAccount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerAccountRepository",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "registerToken",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "unregisterAccount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "unregisterToken",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "updateAccountRepositoryOwner",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace AccountRegisteredEvent {
+  export type InputTuple = [repositoryID: BytesLike, account: AddressLike];
+  export type OutputTuple = [repositoryID: string, account: string];
+  export interface OutputObject {
+    repositoryID: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace AccountRepositoryOwnerUpdatedEvent {
+  export type InputTuple = [repositoryID: BytesLike, operator: AddressLike];
+  export type OutputTuple = [repositoryID: string, operator: string];
+  export interface OutputObject {
+    repositoryID: string;
+    operator: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace AccountRepositoryRegisteredEvent {
+  export type InputTuple = [repositoryID: BytesLike];
+  export type OutputTuple = [repositoryID: string];
+  export interface OutputObject {
+    repositoryID: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace AccountUnregisteredEvent {
+  export type InputTuple = [repositoryID: BytesLike, account: AddressLike];
+  export type OutputTuple = [repositoryID: string, account: string];
+  export interface OutputObject {
+    repositoryID: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenRegisteredEvent {
+  export type InputTuple = [isin: BytesLike, token: AddressLike];
+  export type OutputTuple = [isin: string, token: string];
+  export interface OutputObject {
+    isin: string;
+    token: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenUnregisteredEvent {
+  export type InputTuple = [isin: BytesLike];
+  export type OutputTuple = [isin: string];
+  export interface OutputObject {
+    isin: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface ISecurityTokenDepository extends BaseContract {
+  connect(runner?: ContractRunner | null): ISecurityTokenDepository;
+  waitForDeployment(): Promise<this>;
+
+  interface: ISecurityTokenDepositoryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getTokenAddress: TypedContractMethod<[isin: BytesLike], [string], "view">;
+
+  registerAccount: TypedContractMethod<
+    [repositoryID: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  registerAccountRepository: TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  registerToken: TypedContractMethod<
+    [isin: BytesLike, token: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  unregisterAccount: TypedContractMethod<
+    [repositoryID: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  unregisterToken: TypedContractMethod<[isin: BytesLike], [void], "nonpayable">;
+
+  updateAccountRepositoryOwner: TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getTokenAddress"
+  ): TypedContractMethod<[isin: BytesLike], [string], "view">;
+  getFunction(
+    nameOrSignature: "registerAccount"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "registerAccountRepository"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "registerToken"
+  ): TypedContractMethod<
+    [isin: BytesLike, token: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "unregisterAccount"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "unregisterToken"
+  ): TypedContractMethod<[isin: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "updateAccountRepositoryOwner"
+  ): TypedContractMethod<
+    [repositoryID: BytesLike, owner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "AccountRegistered"
+  ): TypedContractEvent<
+    AccountRegisteredEvent.InputTuple,
+    AccountRegisteredEvent.OutputTuple,
+    AccountRegisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "AccountRepositoryOwnerUpdated"
+  ): TypedContractEvent<
+    AccountRepositoryOwnerUpdatedEvent.InputTuple,
+    AccountRepositoryOwnerUpdatedEvent.OutputTuple,
+    AccountRepositoryOwnerUpdatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "AccountRepositoryRegistered"
+  ): TypedContractEvent<
+    AccountRepositoryRegisteredEvent.InputTuple,
+    AccountRepositoryRegisteredEvent.OutputTuple,
+    AccountRepositoryRegisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "AccountUnregistered"
+  ): TypedContractEvent<
+    AccountUnregisteredEvent.InputTuple,
+    AccountUnregisteredEvent.OutputTuple,
+    AccountUnregisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenRegistered"
+  ): TypedContractEvent<
+    TokenRegisteredEvent.InputTuple,
+    TokenRegisteredEvent.OutputTuple,
+    TokenRegisteredEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenUnregistered"
+  ): TypedContractEvent<
+    TokenUnregisteredEvent.InputTuple,
+    TokenUnregisteredEvent.OutputTuple,
+    TokenUnregisteredEvent.OutputObject
+  >;
+
+  filters: {
+    "AccountRegistered(bytes32,address)": TypedContractEvent<
+      AccountRegisteredEvent.InputTuple,
+      AccountRegisteredEvent.OutputTuple,
+      AccountRegisteredEvent.OutputObject
+    >;
+    AccountRegistered: TypedContractEvent<
+      AccountRegisteredEvent.InputTuple,
+      AccountRegisteredEvent.OutputTuple,
+      AccountRegisteredEvent.OutputObject
+    >;
+
+    "AccountRepositoryOwnerUpdated(bytes32,address)": TypedContractEvent<
+      AccountRepositoryOwnerUpdatedEvent.InputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputObject
+    >;
+    AccountRepositoryOwnerUpdated: TypedContractEvent<
+      AccountRepositoryOwnerUpdatedEvent.InputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputTuple,
+      AccountRepositoryOwnerUpdatedEvent.OutputObject
+    >;
+
+    "AccountRepositoryRegistered(bytes32)": TypedContractEvent<
+      AccountRepositoryRegisteredEvent.InputTuple,
+      AccountRepositoryRegisteredEvent.OutputTuple,
+      AccountRepositoryRegisteredEvent.OutputObject
+    >;
+    AccountRepositoryRegistered: TypedContractEvent<
+      AccountRepositoryRegisteredEvent.InputTuple,
+      AccountRepositoryRegisteredEvent.OutputTuple,
+      AccountRepositoryRegisteredEvent.OutputObject
+    >;
+
+    "AccountUnregistered(bytes32,address)": TypedContractEvent<
+      AccountUnregisteredEvent.InputTuple,
+      AccountUnregisteredEvent.OutputTuple,
+      AccountUnregisteredEvent.OutputObject
+    >;
+    AccountUnregistered: TypedContractEvent<
+      AccountUnregisteredEvent.InputTuple,
+      AccountUnregisteredEvent.OutputTuple,
+      AccountUnregisteredEvent.OutputObject
+    >;
+
+    "TokenRegistered(bytes32,address)": TypedContractEvent<
+      TokenRegisteredEvent.InputTuple,
+      TokenRegisteredEvent.OutputTuple,
+      TokenRegisteredEvent.OutputObject
+    >;
+    TokenRegistered: TypedContractEvent<
+      TokenRegisteredEvent.InputTuple,
+      TokenRegisteredEvent.OutputTuple,
+      TokenRegisteredEvent.OutputObject
+    >;
+
+    "TokenUnregistered(bytes32)": TypedContractEvent<
+      TokenUnregisteredEvent.InputTuple,
+      TokenUnregisteredEvent.OutputTuple,
+      TokenUnregisteredEvent.OutputObject
+    >;
+    TokenUnregistered: TypedContractEvent<
+      TokenUnregisteredEvent.InputTuple,
+      TokenUnregisteredEvent.OutputTuple,
+      TokenUnregisteredEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/TokenSwap.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export declare namespace TokenSwap {
+  export type OrderStruct = {
+    orderID: BytesLike;
+    orderNumber: BigNumberish;
+    exchangeCode: BytesLike;
+    tokenDT: AddressLike;
+    tokenST: AddressLike;
+    partition: BytesLike;
+    holderDT: AddressLike;
+    holderST: AddressLike;
+    amountDT: BigNumberish;
+    amountST: BigNumberish;
+    amountBuyerFee: BigNumberish;
+    amountSellerFee: BigNumberish;
+    amountBuyerTax: BigNumberish;
+    amountSellerTax: BigNumberish;
+    feeTaxCollector: AddressLike;
+  };
+
+  export type OrderStructOutput = [
+    orderID: string,
+    orderNumber: bigint,
+    exchangeCode: string,
+    tokenDT: string,
+    tokenST: string,
+    partition: string,
+    holderDT: string,
+    holderST: string,
+    amountDT: bigint,
+    amountST: bigint,
+    amountBuyerFee: bigint,
+    amountSellerFee: bigint,
+    amountBuyerTax: bigint,
+    amountSellerTax: bigint,
+    feeTaxCollector: string
+  ] & {
+    orderID: string;
+    orderNumber: bigint;
+    exchangeCode: string;
+    tokenDT: string;
+    tokenST: string;
+    partition: string;
+    holderDT: string;
+    holderST: string;
+    amountDT: bigint;
+    amountST: bigint;
+    amountBuyerFee: bigint;
+    amountSellerFee: bigint;
+    amountBuyerTax: bigint;
+    amountSellerTax: bigint;
+    feeTaxCollector: string;
+  };
+}
+
+export interface TokenSwapInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "admins"
+      | "getOrder"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "grantRole"
+      | "hasOrder"
+      | "hasRole"
+      | "initialize"
+      | "isAdmin"
+      | "isOrderCompleted"
+      | "isOrderPartiallyCreated"
+      | "putDTOrder"
+      | "putSTOrder"
+      | "removeOrder"
+      | "revokeRole"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "OrderPartiallyCreated"
+      | "OrderRemoved"
+      | "RoleGranted"
+      | "RoleRevoked"
+      | "Swap"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(functionFragment: "getOrder", values: [BytesLike]): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "hasOrder", values: [BytesLike]): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isOrderCompleted",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isOrderPartiallyCreated",
+    values: [BytesLike, boolean]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "putDTOrder",
+    values: [TokenSwap.OrderStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "putSTOrder",
+    values: [TokenSwap.OrderStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeOrder",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getOrder", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasOrder", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isOrderCompleted",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isOrderPartiallyCreated",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "putDTOrder", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "putSTOrder", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "removeOrder",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace OrderPartiallyCreatedEvent {
+  export type InputTuple = [order: TokenSwap.OrderStruct];
+  export type OutputTuple = [order: TokenSwap.OrderStructOutput];
+  export interface OutputObject {
+    order: TokenSwap.OrderStructOutput;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace OrderRemovedEvent {
+  export type InputTuple = [order: TokenSwap.OrderStruct];
+  export type OutputTuple = [order: TokenSwap.OrderStructOutput];
+  export interface OutputObject {
+    order: TokenSwap.OrderStructOutput;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace SwapEvent {
+  export type InputTuple = [order: TokenSwap.OrderStruct];
+  export type OutputTuple = [order: TokenSwap.OrderStructOutput];
+  export interface OutputObject {
+    order: TokenSwap.OrderStructOutput;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface TokenSwap extends BaseContract {
+  connect(runner?: ContractRunner | null): TokenSwap;
+  waitForDeployment(): Promise<this>;
+
+  interface: TokenSwapInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  getOrder: TypedContractMethod<
+    [orderID: BytesLike],
+    [TokenSwap.OrderStructOutput],
+    "view"
+  >;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasOrder: TypedContractMethod<[orderID: BytesLike], [boolean], "view">;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  initialize: TypedContractMethod<[], [void], "nonpayable">;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isOrderCompleted: TypedContractMethod<
+    [orderID: BytesLike],
+    [boolean],
+    "view"
+  >;
+
+  isOrderPartiallyCreated: TypedContractMethod<
+    [orderID: BytesLike, isDTOrder: boolean],
+    [boolean],
+    "view"
+  >;
+
+  putDTOrder: TypedContractMethod<
+    [partialOrder: TokenSwap.OrderStruct],
+    [void],
+    "nonpayable"
+  >;
+
+  putSTOrder: TypedContractMethod<
+    [partialOrder: TokenSwap.OrderStruct],
+    [void],
+    "nonpayable"
+  >;
+
+  removeOrder: TypedContractMethod<[orderID: BytesLike], [void], "nonpayable">;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getOrder"
+  ): TypedContractMethod<
+    [orderID: BytesLike],
+    [TokenSwap.OrderStructOutput],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasOrder"
+  ): TypedContractMethod<[orderID: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isOrderCompleted"
+  ): TypedContractMethod<[orderID: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isOrderPartiallyCreated"
+  ): TypedContractMethod<
+    [orderID: BytesLike, isDTOrder: boolean],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "putDTOrder"
+  ): TypedContractMethod<
+    [partialOrder: TokenSwap.OrderStruct],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "putSTOrder"
+  ): TypedContractMethod<
+    [partialOrder: TokenSwap.OrderStruct],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "removeOrder"
+  ): TypedContractMethod<[orderID: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "OrderPartiallyCreated"
+  ): TypedContractEvent<
+    OrderPartiallyCreatedEvent.InputTuple,
+    OrderPartiallyCreatedEvent.OutputTuple,
+    OrderPartiallyCreatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "OrderRemoved"
+  ): TypedContractEvent<
+    OrderRemovedEvent.InputTuple,
+    OrderRemovedEvent.OutputTuple,
+    OrderRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Swap"
+  ): TypedContractEvent<
+    SwapEvent.InputTuple,
+    SwapEvent.OutputTuple,
+    SwapEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "OrderPartiallyCreated(tuple)": TypedContractEvent<
+      OrderPartiallyCreatedEvent.InputTuple,
+      OrderPartiallyCreatedEvent.OutputTuple,
+      OrderPartiallyCreatedEvent.OutputObject
+    >;
+    OrderPartiallyCreated: TypedContractEvent<
+      OrderPartiallyCreatedEvent.InputTuple,
+      OrderPartiallyCreatedEvent.OutputTuple,
+      OrderPartiallyCreatedEvent.OutputObject
+    >;
+
+    "OrderRemoved(tuple)": TypedContractEvent<
+      OrderRemovedEvent.InputTuple,
+      OrderRemovedEvent.OutputTuple,
+      OrderRemovedEvent.OutputObject
+    >;
+    OrderRemoved: TypedContractEvent<
+      OrderRemovedEvent.InputTuple,
+      OrderRemovedEvent.OutputTuple,
+      OrderRemovedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+
+    "Swap(tuple)": TypedContractEvent<
+      SwapEvent.InputTuple,
+      SwapEvent.OutputTuple,
+      SwapEvent.OutputObject
+    >;
+    Swap: TypedContractEvent<
+      SwapEvent.InputTuple,
+      SwapEvent.OutputTuple,
+      SwapEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/AccessControl.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface AccessControlInterface extends Interface {
+  getFunction(
+    nameOrSignature: "getRoleMembers" | "getRoleMembersLength" | "hasRole"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface AccessControl extends BaseContract {
+  connect(runner?: ContractRunner | null): AccessControl;
+  waitForDeployment(): Promise<this>;
+
+  interface: AccessControlInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/Admin.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface AdminInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "admins"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "grantRole"
+      | "hasRole"
+      | "isAdmin"
+      | "revokeRole"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Admin extends BaseContract {
+  connect(runner?: ContractRunner | null): Admin;
+  waitForDeployment(): Promise<this>;
+
+  interface: AdminInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/Controller.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface ControllerInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "CONTROLLER_ROLE"
+      | "controllers"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isController"
+      | "numOfControllers"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "CONTROLLER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "controllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isController",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "numOfControllers",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "CONTROLLER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "controllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "numOfControllers",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Controller extends BaseContract {
+  connect(runner?: ContractRunner | null): Controller;
+  waitForDeployment(): Promise<this>;
+
+  interface: ControllerInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  CONTROLLER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  controllers: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isController: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  numOfControllers: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "CONTROLLER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "controllers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isController"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "numOfControllers"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/Issuer.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IssuerInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ISSUER_ROLE"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isIssuer"
+      | "issuers"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ISSUER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isIssuer",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "issuers", values?: undefined): string;
+
+  decodeFunctionResult(
+    functionFragment: "ISSUER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isIssuer", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "issuers", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Issuer extends BaseContract {
+  connect(runner?: ContractRunner | null): Issuer;
+  waitForDeployment(): Promise<this>;
+
+  interface: IssuerInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ISSUER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isIssuer: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  issuers: TypedContractMethod<[], [string[]], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ISSUER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isIssuer"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issuers"
+  ): TypedContractMethod<[], [string[]], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/KSDOperator.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface KSDOperatorInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "KSDOperators"
+      | "KSD_OPERATOR_ROLE"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isKSDOperator"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "KSDOperators",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "KSD_OPERATOR_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isKSDOperator",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "KSDOperators",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "KSD_OPERATOR_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isKSDOperator",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface KSDOperator extends BaseContract {
+  connect(runner?: ContractRunner | null): KSDOperator;
+  waitForDeployment(): Promise<this>;
+
+  interface: KSDOperatorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  KSDOperators: TypedContractMethod<[], [string[]], "view">;
+
+  KSD_OPERATOR_ROLE: TypedContractMethod<[], [string], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isKSDOperator: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "KSDOperators"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "KSD_OPERATOR_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isKSDOperator"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/Locker.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface LockerInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "LOCKER_ROLE"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isLocker"
+      | "lockers"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "LOCKER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isLocker",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "lockers", values?: undefined): string;
+
+  decodeFunctionResult(
+    functionFragment: "LOCKER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isLocker", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "lockers", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Locker extends BaseContract {
+  connect(runner?: ContractRunner | null): Locker;
+  waitForDeployment(): Promise<this>;
+
+  interface: LockerInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  LOCKER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isLocker: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  lockers: TypedContractMethod<[], [string[]], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "LOCKER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isLocker"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "lockers"
+  ): TypedContractMethod<[], [string[]], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/Operator.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface OperatorInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "OPERATOR_ROLE"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasRole"
+      | "isOperator"
+      | "operators"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "OPERATOR_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isOperator",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "operators", values?: undefined): string;
+
+  decodeFunctionResult(
+    functionFragment: "OPERATOR_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "operators", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Operator extends BaseContract {
+  connect(runner?: ContractRunner | null): Operator;
+  waitForDeployment(): Promise<this>;
+
+  interface: OperatorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  OPERATOR_ROLE: TypedContractMethod<[], [string], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isOperator: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  operators: TypedContractMethod<[], [string[]], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "OPERATOR_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isOperator"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "operators"
+  ): TypedContractMethod<[], [string[]], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/access/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { AccessControl } from "./AccessControl";
+export type { Admin } from "./Admin";
+export type { Controller } from "./Controller";
+export type { Issuer } from "./Issuer";
+export type { KSDOperator } from "./KSDOperator";
+export type { Locker } from "./Locker";
+export type { Operator } from "./Operator";

typechain2/contracts/depository/AccountManagement.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../../common";
+
+export interface AccountManagementInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface AccountManagement extends BaseContract {
+  connect(runner?: ContractRunner | null): AccountManagement;
+  waitForDeployment(): Promise<this>;
+
+  interface: AccountManagementInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/depository/AccountRepositoryManagement.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../../common";
+
+export interface AccountRepositoryManagementInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface AccountRepositoryManagement extends BaseContract {
+  connect(runner?: ContractRunner | null): AccountRepositoryManagement;
+  waitForDeployment(): Promise<this>;
+
+  interface: AccountRepositoryManagementInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/depository/Depository.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../../common";
+
+export interface DepositoryInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Depository extends BaseContract {
+  connect(runner?: ContractRunner | null): Depository;
+  waitForDeployment(): Promise<this>;
+
+  interface: DepositoryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/depository/DepositoryBase.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  FunctionFragment,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+} from "../../common";
+
+export interface DepositoryBaseInterface extends Interface {}
+
+export interface DepositoryBase extends BaseContract {
+  connect(runner?: ContractRunner | null): DepositoryBase;
+  waitForDeployment(): Promise<this>;
+
+  interface: DepositoryBaseInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  filters: {};
+}

typechain2/contracts/depository/KSDStandard.sol/Partitioned.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../common";
+
+export interface PartitionedInterface extends Interface {
+  getFunction(nameOrSignature: "getDefaultPartitions"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getDefaultPartitions",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getDefaultPartitions",
+    data: BytesLike
+  ): Result;
+}
+
+export interface Partitioned extends BaseContract {
+  connect(runner?: ContractRunner | null): Partitioned;
+  waitForDeployment(): Promise<this>;
+
+  interface: PartitionedInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getDefaultPartitions: TypedContractMethod<[], [string[]], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getDefaultPartitions"
+  ): TypedContractMethod<[], [string[]], "view">;
+
+  filters: {};
+}

typechain2/contracts/depository/KSDStandard.sol/Queryable.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../common";
+
+export interface QueryableInterface extends Interface {
+  getFunction(
+    nameOrSignature: "getHoldersWithNonZeroBalance"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getHoldersWithNonZeroBalance",
+    values: [AddressLike, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "getHoldersWithNonZeroBalance",
+    data: BytesLike
+  ): Result;
+}
+
+export interface Queryable extends BaseContract {
+  connect(runner?: ContractRunner | null): Queryable;
+  waitForDeployment(): Promise<this>;
+
+  interface: QueryableInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getHoldersWithNonZeroBalance: TypedContractMethod<
+    [startAddress: AddressLike, count: BigNumberish],
+    [[string[], string] & { holders: string[]; nextAddress: string }],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getHoldersWithNonZeroBalance"
+  ): TypedContractMethod<
+    [startAddress: AddressLike, count: BigNumberish],
+    [[string[], string] & { holders: string[]; nextAddress: string }],
+    "view"
+  >;
+
+  filters: {};
+}

typechain2/contracts/depository/KSDStandard.sol/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { KSDStandard } from "./KSDStandard";
+export type { Partitioned } from "./Partitioned";
+export type { Queryable } from "./Queryable";

typechain2/contracts/depository/PledgeManagement.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../../common";
+
+export interface PledgeManagementInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface PledgeManagement extends BaseContract {
+  connect(runner?: ContractRunner | null): PledgeManagement;
+  waitForDeployment(): Promise<this>;
+
+  interface: PledgeManagementInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/depository/TokenManagement.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  FunctionFragment,
+  Interface,
+  EventFragment,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+} from "../../common";
+
+export interface TokenManagementInterface extends Interface {
+  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface TokenManagement extends BaseContract {
+  connect(runner?: ContractRunner | null): TokenManagement;
+  waitForDeployment(): Promise<this>;
+
+  interface: TokenManagementInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/depository/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as ksdStandardSol from "./KSDStandard.sol";
+export type { ksdStandardSol };
+export type { AccountManagement } from "./AccountManagement";
+export type { AccountRepositoryManagement } from "./AccountRepositoryManagement";
+export type { Depository } from "./Depository";
+export type { DepositoryBase } from "./DepositoryBase";
+export type { IKSDStandard } from "./IKSDStandard";
+export type { PledgeManagement } from "./PledgeManagement";
+export type { TokenManagement } from "./TokenManagement";

typechain2/contracts/extensions/AccountList.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface AccountListInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "addAddress"
+      | "addAddresses"
+      | "getIndex"
+      | "readAddresses"
+      | "removeAddress"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "addAddress",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "addAddresses",
+    values: [AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getIndex",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "readAddresses",
+    values: [AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeAddress",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "addAddress", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "addAddresses",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getIndex", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "readAddresses",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeAddress",
+    data: BytesLike
+  ): Result;
+}
+
+export interface AccountList extends BaseContract {
+  connect(runner?: ContractRunner | null): AccountList;
+  waitForDeployment(): Promise<this>;
+
+  interface: AccountListInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  addAddress: TypedContractMethod<
+    [account: AddressLike],
+    [boolean],
+    "nonpayable"
+  >;
+
+  addAddresses: TypedContractMethod<
+    [accounts: AddressLike[]],
+    [boolean],
+    "nonpayable"
+  >;
+
+  getIndex: TypedContractMethod<[target: AddressLike], [bigint], "view">;
+
+  readAddresses: TypedContractMethod<
+    [start: AddressLike, count: BigNumberish],
+    [[string[], string] & { range: string[]; nextAddress: string }],
+    "view"
+  >;
+
+  removeAddress: TypedContractMethod<
+    [account: AddressLike],
+    [bigint],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "addAddress"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "nonpayable">;
+  getFunction(
+    nameOrSignature: "addAddresses"
+  ): TypedContractMethod<[accounts: AddressLike[]], [boolean], "nonpayable">;
+  getFunction(
+    nameOrSignature: "getIndex"
+  ): TypedContractMethod<[target: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "readAddresses"
+  ): TypedContractMethod<
+    [start: AddressLike, count: BigNumberish],
+    [[string[], string] & { range: string[]; nextAddress: string }],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "removeAddress"
+  ): TypedContractMethod<[account: AddressLike], [bigint], "nonpayable">;
+
+  filters: {};
+}

typechain2/contracts/extensions/CertificateValidator.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  FunctionFragment,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+} from "../../common";
+
+export interface CertificateValidatorInterface extends Interface {}
+
+export interface CertificateValidator extends BaseContract {
+  connect(runner?: ContractRunner | null): CertificateValidator;
+  waitForDeployment(): Promise<this>;
+
+  interface: CertificateValidatorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  filters: {};
+}

typechain2/contracts/extensions/Controllable.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface ControllableInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "CONTROLLER_ROLE"
+      | "admins"
+      | "authorizeController"
+      | "controllers"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "grantRole"
+      | "hasRole"
+      | "isAdmin"
+      | "isController"
+      | "numOfControllers"
+      | "revokeController"
+      | "revokeRole"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "ControllerAuthorized"
+      | "ControllerRevoked"
+      | "Initialized"
+      | "RoleGranted"
+      | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "CONTROLLER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "authorizeController",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "controllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isController",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "numOfControllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeController",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "CONTROLLER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "authorizeController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "controllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "numOfControllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "revokeController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+}
+
+export namespace ControllerAuthorizedEvent {
+  export type InputTuple = [issuer: AddressLike, newController: AddressLike];
+  export type OutputTuple = [issuer: string, newController: string];
+  export interface OutputObject {
+    issuer: string;
+    newController: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ControllerRevokedEvent {
+  export type InputTuple = [issuer: AddressLike, oldController: AddressLike];
+  export type OutputTuple = [issuer: string, oldController: string];
+  export interface OutputObject {
+    issuer: string;
+    oldController: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Controllable extends BaseContract {
+  connect(runner?: ContractRunner | null): Controllable;
+  waitForDeployment(): Promise<this>;
+
+  interface: ControllableInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  CONTROLLER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  authorizeController: TypedContractMethod<
+    [controller: AddressLike, certificate: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  controllers: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isController: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  numOfControllers: TypedContractMethod<[], [bigint], "view">;
+
+  revokeController: TypedContractMethod<
+    [controller: AddressLike, certificate: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "CONTROLLER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "authorizeController"
+  ): TypedContractMethod<
+    [controller: AddressLike, certificate: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "controllers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isController"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "numOfControllers"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "revokeController"
+  ): TypedContractMethod<
+    [controller: AddressLike, certificate: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "ControllerAuthorized"
+  ): TypedContractEvent<
+    ControllerAuthorizedEvent.InputTuple,
+    ControllerAuthorizedEvent.OutputTuple,
+    ControllerAuthorizedEvent.OutputObject
+  >;
+  getEvent(
+    key: "ControllerRevoked"
+  ): TypedContractEvent<
+    ControllerRevokedEvent.InputTuple,
+    ControllerRevokedEvent.OutputTuple,
+    ControllerRevokedEvent.OutputObject
+  >;
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "ControllerAuthorized(address,address)": TypedContractEvent<
+      ControllerAuthorizedEvent.InputTuple,
+      ControllerAuthorizedEvent.OutputTuple,
+      ControllerAuthorizedEvent.OutputObject
+    >;
+    ControllerAuthorized: TypedContractEvent<
+      ControllerAuthorizedEvent.InputTuple,
+      ControllerAuthorizedEvent.OutputTuple,
+      ControllerAuthorizedEvent.OutputObject
+    >;
+
+    "ControllerRevoked(address,address)": TypedContractEvent<
+      ControllerRevokedEvent.InputTuple,
+      ControllerRevokedEvent.OutputTuple,
+      ControllerRevokedEvent.OutputObject
+    >;
+    ControllerRevoked: TypedContractEvent<
+      ControllerRevokedEvent.InputTuple,
+      ControllerRevokedEvent.OutputTuple,
+      ControllerRevokedEvent.OutputObject
+    >;
+
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/extensions/HoldersQuery.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface HoldersQueryInterface extends Interface {
+  getFunction(
+    nameOrSignature: "getHolders" | "getHoldersWithNonZeroBalance"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "getHolders",
+    values: [AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getHoldersWithNonZeroBalance",
+    values: [AddressLike, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "getHolders", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getHoldersWithNonZeroBalance",
+    data: BytesLike
+  ): Result;
+}
+
+export interface HoldersQuery extends BaseContract {
+  connect(runner?: ContractRunner | null): HoldersQuery;
+  waitForDeployment(): Promise<this>;
+
+  interface: HoldersQueryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getHolders: TypedContractMethod<
+    [startAddress: AddressLike, count: BigNumberish],
+    [[string[], string] & { holders: string[]; nextAddress: string }],
+    "view"
+  >;
+
+  getHoldersWithNonZeroBalance: TypedContractMethod<
+    [startAddress: AddressLike, count: BigNumberish],
+    [[string[], string] & { holders: string[]; nextAddress: string }],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getHolders"
+  ): TypedContractMethod<
+    [startAddress: AddressLike, count: BigNumberish],
+    [[string[], string] & { holders: string[]; nextAddress: string }],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getHoldersWithNonZeroBalance"
+  ): TypedContractMethod<
+    [startAddress: AddressLike, count: BigNumberish],
+    [[string[], string] & { holders: string[]; nextAddress: string }],
+    "view"
+  >;
+
+  filters: {};
+}

typechain2/contracts/extensions/ILockable.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export declare namespace ERC1400StorageDomain {
+  export type LockStruct = {
+    partition: BytesLike;
+    lockType: BytesLike;
+    amount: BigNumberish;
+  };
+
+  export type LockStructOutput = [
+    partition: string,
+    lockType: string,
+    amount: bigint
+  ] & { partition: string; lockType: string; amount: bigint };
+}
+
+export interface ILockableInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "createLock"
+      | "getLocks"
+      | "getLocksByPartition"
+      | "hasLock"
+      | "lockedAmount"
+      | "removeLock"
+      | "totalLockedAmount"
+      | "totalLockedAmountByPartition"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "createLock",
+    values: [BytesLike, BytesLike, AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getLocks",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getLocksByPartition",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasLock",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "lockedAmount",
+    values: [AddressLike, BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLock",
+    values: [BytesLike, BytesLike, AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalLockedAmount",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalLockedAmountByPartition",
+    values: [AddressLike, BytesLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "createLock", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getLocks", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getLocksByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasLock", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "lockedAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "removeLock", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalLockedAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalLockedAmountByPartition",
+    data: BytesLike
+  ): Result;
+}
+
+export interface ILockable extends BaseContract {
+  connect(runner?: ContractRunner | null): ILockable;
+  waitForDeployment(): Promise<this>;
+
+  interface: ILockableInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  createLock: TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  getLocks: TypedContractMethod<
+    [account: AddressLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+
+  getLocksByPartition: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+
+  hasLock: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [boolean],
+    "view"
+  >;
+
+  lockedAmount: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike, lockType: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  removeLock: TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  totalLockedAmount: TypedContractMethod<
+    [account: AddressLike],
+    [bigint],
+    "view"
+  >;
+
+  totalLockedAmountByPartition: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "createLock"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "getLocks"
+  ): TypedContractMethod<
+    [account: AddressLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getLocksByPartition"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "hasLock"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "lockedAmount"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike, lockType: BytesLike],
+    [bigint],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "removeLock"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "totalLockedAmount"
+  ): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "totalLockedAmountByPartition"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  filters: {};
+}

typechain2/contracts/extensions/Lockable.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export declare namespace ERC1400StorageDomain {
+  export type LockStruct = {
+    partition: BytesLike;
+    lockType: BytesLike;
+    amount: BigNumberish;
+  };
+
+  export type LockStructOutput = [
+    partition: string,
+    lockType: string,
+    amount: bigint
+  ] & { partition: string; lockType: string; amount: bigint };
+}
+
+export interface LockableInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "LOCKER_ROLE"
+      | "createLock"
+      | "getLocks"
+      | "getLocksByPartition"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasLock"
+      | "hasRole"
+      | "isLocker"
+      | "lockedAmount"
+      | "lockers"
+      | "removeLock"
+      | "totalLockedAmount"
+      | "totalLockedAmountByPartition"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "LockCreated"
+      | "LockReleased"
+      | "RoleGranted"
+      | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "LOCKER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "createLock",
+    values: [BytesLike, BytesLike, AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getLocks",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getLocksByPartition",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasLock",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isLocker",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "lockedAmount",
+    values: [AddressLike, BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "lockers", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "removeLock",
+    values: [BytesLike, BytesLike, AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalLockedAmount",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalLockedAmountByPartition",
+    values: [AddressLike, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "LOCKER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "createLock", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getLocks", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getLocksByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasLock", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isLocker", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "lockedAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "lockers", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "removeLock", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "totalLockedAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalLockedAmountByPartition",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace LockCreatedEvent {
+  export type InputTuple = [
+    account: AddressLike,
+    partition: BytesLike,
+    lockType: BytesLike,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [
+    account: string,
+    partition: string,
+    lockType: string,
+    value: bigint
+  ];
+  export interface OutputObject {
+    account: string;
+    partition: string;
+    lockType: string;
+    value: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace LockReleasedEvent {
+  export type InputTuple = [
+    account: AddressLike,
+    partition: BytesLike,
+    lockType: BytesLike,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [
+    account: string,
+    partition: string,
+    lockType: string,
+    value: bigint
+  ];
+  export interface OutputObject {
+    account: string;
+    partition: string;
+    lockType: string;
+    value: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Lockable extends BaseContract {
+  connect(runner?: ContractRunner | null): Lockable;
+  waitForDeployment(): Promise<this>;
+
+  interface: LockableInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  LOCKER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  createLock: TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  getLocks: TypedContractMethod<
+    [account: AddressLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+
+  getLocksByPartition: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  hasLock: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [boolean],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isLocker: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  lockedAmount: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike, lockType: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  lockers: TypedContractMethod<[], [string[]], "view">;
+
+  removeLock: TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  totalLockedAmount: TypedContractMethod<
+    [account: AddressLike],
+    [bigint],
+    "view"
+  >;
+
+  totalLockedAmountByPartition: TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "LOCKER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "createLock"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "getLocks"
+  ): TypedContractMethod<
+    [account: AddressLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getLocksByPartition"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [ERC1400StorageDomain.LockStructOutput[]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "hasLock"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isLocker"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "lockedAmount"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike, lockType: BytesLike],
+    [bigint],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "lockers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "removeLock"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      lockType: BytesLike,
+      holder: AddressLike,
+      value: BigNumberish
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "totalLockedAmount"
+  ): TypedContractMethod<[account: AddressLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "totalLockedAmountByPartition"
+  ): TypedContractMethod<
+    [account: AddressLike, partition: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "LockCreated"
+  ): TypedContractEvent<
+    LockCreatedEvent.InputTuple,
+    LockCreatedEvent.OutputTuple,
+    LockCreatedEvent.OutputObject
+  >;
+  getEvent(
+    key: "LockReleased"
+  ): TypedContractEvent<
+    LockReleasedEvent.InputTuple,
+    LockReleasedEvent.OutputTuple,
+    LockReleasedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "LockCreated(address,bytes32,bytes32,uint256)": TypedContractEvent<
+      LockCreatedEvent.InputTuple,
+      LockCreatedEvent.OutputTuple,
+      LockCreatedEvent.OutputObject
+    >;
+    LockCreated: TypedContractEvent<
+      LockCreatedEvent.InputTuple,
+      LockCreatedEvent.OutputTuple,
+      LockCreatedEvent.OutputObject
+    >;
+
+    "LockReleased(address,bytes32,bytes32,uint256)": TypedContractEvent<
+      LockReleasedEvent.InputTuple,
+      LockReleasedEvent.OutputTuple,
+      LockReleasedEvent.OutputObject
+    >;
+    LockReleased: TypedContractEvent<
+      LockReleasedEvent.InputTuple,
+      LockReleasedEvent.OutputTuple,
+      LockReleasedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/extensions/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { AccountList } from "./AccountList";
+export type { CertificateValidator } from "./CertificateValidator";
+export type { Controllable } from "./Controllable";
+export type { HoldersQuery } from "./HoldersQuery";
+export type { ILockable } from "./ILockable";
+export type { Lockable } from "./Lockable";

typechain2/contracts/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as erc from "./ERC";
+export type { erc };
+import type * as globalKycRegistrySol from "./GlobalKycRegistry.sol";
+export type { globalKycRegistrySol };
+import type * as access from "./access";
+export type { access };
+import type * as depository from "./depository";
+export type { depository };
+import type * as extensions from "./extensions";
+export type { extensions };
+import type * as mock from "./mock";
+export type { mock };
+import type * as partitions from "./partitions";
+export type { partitions };
+import type * as rules from "./rules";
+export type { rules };
+export type { Connector } from "./Connector";
+export type { IKSDStandard } from "./IKSDStandard";
+export type { IProvideSelector } from "./IProvideSelector";
+export type { ISecuritiesDepository } from "./ISecuritiesDepository";
+export type { KSDStandard } from "./KSDStandard";
+export type { SecuritiesDepository } from "./SecuritiesDepository";
+export type { SecurityToken } from "./SecurityToken";
+export type { TokenSwap } from "./TokenSwap";

typechain2/contracts/mock/GlobalKycMockUpgrade.sol/MockGlobalKycUpgrade.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../common";
+
+export interface MockGlobalKycUpgradeInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "KYCtokenHolders"
+      | "OPERATOR_ROLE"
+      | "admins"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "grantRole"
+      | "hasRole"
+      | "holderCount"
+      | "initialize"
+      | "isAdmin"
+      | "isOperator"
+      | "isTokenHolderKYC"
+      | "operators"
+      | "revokeRole"
+      | "unKYCtokenHolders"
+      | "version"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "KYCtokenHolders",
+    values: [AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "OPERATOR_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "holderCount",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isOperator",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isTokenHolderKYC",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "operators", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "unKYCtokenHolders",
+    values: [AddressLike[]]
+  ): string;
+  encodeFunctionData(functionFragment: "version", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "KYCtokenHolders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "OPERATOR_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "holderCount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isOperator", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isTokenHolderKYC",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "operators", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "unKYCtokenHolders",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface MockGlobalKycUpgrade extends BaseContract {
+  connect(runner?: ContractRunner | null): MockGlobalKycUpgrade;
+  waitForDeployment(): Promise<this>;
+
+  interface: MockGlobalKycUpgradeInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  KYCtokenHolders: TypedContractMethod<
+    [tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  OPERATOR_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  holderCount: TypedContractMethod<[], [bigint], "view">;
+
+  initialize: TypedContractMethod<[], [void], "nonpayable">;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isOperator: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isTokenHolderKYC: TypedContractMethod<
+    [tokenHolder: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  operators: TypedContractMethod<[], [string[]], "view">;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  unKYCtokenHolders: TypedContractMethod<
+    [tokenHolders: AddressLike[]],
+    [void],
+    "nonpayable"
+  >;
+
+  version: TypedContractMethod<[], [bigint], "view">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "KYCtokenHolders"
+  ): TypedContractMethod<[tokenHolders: AddressLike[]], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "OPERATOR_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "holderCount"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isOperator"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isTokenHolderKYC"
+  ): TypedContractMethod<[tokenHolder: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "operators"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "unKYCtokenHolders"
+  ): TypedContractMethod<[tokenHolders: AddressLike[]], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "version"
+  ): TypedContractMethod<[], [bigint], "view">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/mock/GlobalKycMockUpgrade.sol/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { MockGlobalKycUpgrade } from "./MockGlobalKycUpgrade";

typechain2/contracts/mock/MockConnector.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface MockConnectorInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ADMIN_ROLE"
+      | "admins"
+      | "canCreateLockByPartition_"
+      | "canIssueByPartition_"
+      | "canRedeemByPartition_"
+      | "canRedeem_"
+      | "canTransferByPartitions_"
+      | "canTransferFrom_"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "getTarget"
+      | "getTargetImplementation"
+      | "grantRole"
+      | "hasRole"
+      | "isAdmin"
+      | "isPartition_"
+      | "revokeRole"
+      | "setTarget"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "Initialized" | "RoleGranted" | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ADMIN_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "admins", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "canCreateLockByPartition_",
+    values: [AddressLike, BytesLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canIssueByPartition_",
+    values: [BytesLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeemByPartition_",
+    values: [AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeem_",
+    values: [AddressLike, BigNumberish, BytesLike[], BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartitions_",
+    values: [
+      AddressLike,
+      AddressLike,
+      BytesLike,
+      BytesLike,
+      BigNumberish,
+      BytesLike
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferFrom_",
+    values: [AddressLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "getTarget", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "getTargetImplementation",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "grantRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isAdmin",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isPartition_",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "revokeRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setTarget",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "canCreateLockByPartition_",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canIssueByPartition_",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canRedeemByPartition_",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "canRedeem_", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartitions_",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferFrom_",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getTarget", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getTargetImplementation",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isPartition_",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "setTarget", data: BytesLike): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface MockConnector extends BaseContract {
+  connect(runner?: ContractRunner | null): MockConnector;
+  waitForDeployment(): Promise<this>;
+
+  interface: MockConnectorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ADMIN_ROLE: TypedContractMethod<[], [string], "view">;
+
+  admins: TypedContractMethod<[], [string[]], "view">;
+
+  canCreateLockByPartition_: TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  canIssueByPartition_: TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  canRedeemByPartition_: TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  canRedeem_: TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  canTransferByPartitions_: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  canTransferFrom_: TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getTarget: TypedContractMethod<[], [string], "view">;
+
+  getTargetImplementation: TypedContractMethod<[], [string], "view">;
+
+  grantRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  isAdmin: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isPartition_: TypedContractMethod<
+    [partition: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  revokeRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setTarget: TypedContractMethod<[target: AddressLike], [void], "nonpayable">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ADMIN_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "admins"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "canCreateLockByPartition_"
+  ): TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "canIssueByPartition_"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeemByPartition_"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeem_"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartitions_"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferFrom_"
+  ): TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getTarget"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getTargetImplementation"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "grantRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isAdmin"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isPartition_"
+  ): TypedContractMethod<[partition: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "revokeRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setTarget"
+  ): TypedContractMethod<[target: AddressLike], [void], "nonpayable">;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/mock/MockRules.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export declare namespace IPartitions {
+  export type VariableStruct = { key: BytesLike; kind: string };
+
+  export type VariableStructOutput = [key: string, kind: string] & {
+    key: string;
+    kind: string;
+  };
+
+  export type PartitionStruct = { name: BytesLike; data: BytesLike };
+
+  export type PartitionStructOutput = [name: string, data: string] & {
+    name: string;
+    data: string;
+  };
+}
+
+export interface MockRulesInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "CONTROLLER_ROLE"
+      | "ISSUER_ROLE"
+      | "canCreateLockByPartition"
+      | "canIssueByPartition"
+      | "canRedeem"
+      | "canRedeemByPartition"
+      | "canTransferByPartition"
+      | "canTransferByPartitions"
+      | "canTransferFrom"
+      | "controllers"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "getSelectors"
+      | "getValue"
+      | "getVariables"
+      | "hasRole"
+      | "initialize"
+      | "isController"
+      | "isIssuer"
+      | "isKey"
+      | "isPartition"
+      | "issuers"
+      | "newStateVariable"
+      | "numOfControllers"
+      | "partitions"
+      | "removePartition"
+      | "setNewVariable"
+      | "setPartition"
+      | "setValues"
+      | "setVariables"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "PartitionRemoved"
+      | "PartitionSet"
+      | "RoleGranted"
+      | "RoleRevoked"
+      | "TokenSet"
+      | "ValueRemoved"
+      | "ValueSet"
+      | "VariableSet"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "CONTROLLER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "ISSUER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canCreateLockByPartition",
+    values: [AddressLike, BytesLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canIssueByPartition",
+    values: [BytesLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeem",
+    values: [AddressLike, BigNumberish, BytesLike[], BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeemByPartition",
+    values: [AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartition",
+    values: [AddressLike, AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartitions",
+    values: [
+      AddressLike,
+      AddressLike,
+      BytesLike,
+      BytesLike,
+      BigNumberish,
+      BytesLike
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferFrom",
+    values: [AddressLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "controllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSelectors",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getValue",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVariables",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values: [IPartitions.PartitionStruct[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isController",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isIssuer",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "isKey", values: [BytesLike]): string;
+  encodeFunctionData(
+    functionFragment: "isPartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "issuers", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "newStateVariable",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "numOfControllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "partitions",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removePartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setNewVariable",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setPartition",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setValues",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setVariables",
+    values: [IPartitions.VariableStruct[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "CONTROLLER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "ISSUER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canCreateLockByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canIssueByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "canRedeem", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "canRedeemByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartitions",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferFrom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "controllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSelectors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getValue", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getVariables",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "isIssuer", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isKey", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "issuers", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "newStateVariable",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "numOfControllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "partitions", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "removePartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setNewVariable",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "setValues", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setVariables",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionRemovedEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionSetEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenSetEvent {
+  export type InputTuple = [token: AddressLike];
+  export type OutputTuple = [token: string];
+  export interface OutputObject {
+    token: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueRemovedEvent {
+  export type InputTuple = [partition: BytesLike, key: BytesLike];
+  export type OutputTuple = [partition: string, key: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueSetEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    key: BytesLike,
+    value: BytesLike
+  ];
+  export type OutputTuple = [partition: string, key: string, value: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+    value: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace VariableSetEvent {
+  export type InputTuple = [key: BytesLike, kind: string];
+  export type OutputTuple = [key: string, kind: string];
+  export interface OutputObject {
+    key: string;
+    kind: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface MockRules extends BaseContract {
+  connect(runner?: ContractRunner | null): MockRules;
+  waitForDeployment(): Promise<this>;
+
+  interface: MockRulesInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  CONTROLLER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  ISSUER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  canCreateLockByPartition: TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [[string, string]],
+    "view"
+  >;
+
+  canIssueByPartition: TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canRedeem: TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      arg3: BytesLike
+    ],
+    [[string, string]],
+    "view"
+  >;
+
+  canRedeemByPartition: TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canTransferByPartition: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg4: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canTransferByPartitions: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      arg5: BytesLike
+    ],
+    [[string, string, string, string]],
+    "view"
+  >;
+
+  canTransferFrom: TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, arg3: BytesLike],
+    [[string, string]],
+    "view"
+  >;
+
+  controllers: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getSelectors: TypedContractMethod<[], [string], "view">;
+
+  getValue: TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getVariables: TypedContractMethod<
+    [],
+    [IPartitions.VariableStructOutput[]],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  initialize: TypedContractMethod<
+    [initialPartitions: IPartitions.PartitionStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  isController: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isIssuer: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isKey: TypedContractMethod<[key: BytesLike], [boolean], "view">;
+
+  isPartition: TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+
+  issuers: TypedContractMethod<[], [string[]], "view">;
+
+  newStateVariable: TypedContractMethod<[], [bigint], "view">;
+
+  numOfControllers: TypedContractMethod<[], [bigint], "view">;
+
+  partitions: TypedContractMethod<[], [string[]], "view">;
+
+  removePartition: TypedContractMethod<
+    [partition: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setNewVariable: TypedContractMethod<
+    [newValue: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  setPartition: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setValues: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setVariables: TypedContractMethod<
+    [variables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "CONTROLLER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "ISSUER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "canCreateLockByPartition"
+  ): TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canIssueByPartition"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeem"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      arg3: BytesLike
+    ],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeemByPartition"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartition"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg4: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartitions"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      arg5: BytesLike
+    ],
+    [[string, string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferFrom"
+  ): TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, arg3: BytesLike],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "controllers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getSelectors"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getValue"
+  ): TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getVariables"
+  ): TypedContractMethod<[], [IPartitions.VariableStructOutput[]], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<
+    [initialPartitions: IPartitions.PartitionStruct[]],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "isController"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isIssuer"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isKey"
+  ): TypedContractMethod<[key: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isPartition"
+  ): TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issuers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "newStateVariable"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "numOfControllers"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "partitions"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "removePartition"
+  ): TypedContractMethod<[partition: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setNewVariable"
+  ): TypedContractMethod<[newValue: BigNumberish], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setPartition"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setValues"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setVariables"
+  ): TypedContractMethod<
+    [variables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionRemoved"
+  ): TypedContractEvent<
+    PartitionRemovedEvent.InputTuple,
+    PartitionRemovedEvent.OutputTuple,
+    PartitionRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionSet"
+  ): TypedContractEvent<
+    PartitionSetEvent.InputTuple,
+    PartitionSetEvent.OutputTuple,
+    PartitionSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenSet"
+  ): TypedContractEvent<
+    TokenSetEvent.InputTuple,
+    TokenSetEvent.OutputTuple,
+    TokenSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueRemoved"
+  ): TypedContractEvent<
+    ValueRemovedEvent.InputTuple,
+    ValueRemovedEvent.OutputTuple,
+    ValueRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueSet"
+  ): TypedContractEvent<
+    ValueSetEvent.InputTuple,
+    ValueSetEvent.OutputTuple,
+    ValueSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "VariableSet"
+  ): TypedContractEvent<
+    VariableSetEvent.InputTuple,
+    VariableSetEvent.OutputTuple,
+    VariableSetEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "PartitionRemoved(bytes32)": TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+    PartitionRemoved: TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+
+    "PartitionSet(bytes32)": TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+    PartitionSet: TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+
+    "TokenSet(address)": TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+    TokenSet: TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+
+    "ValueRemoved(bytes32,bytes32)": TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+    ValueRemoved: TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+
+    "ValueSet(bytes32,bytes32,bytes32)": TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+    ValueSet: TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+
+    "VariableSet(bytes32,string)": TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+    VariableSet: TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/mock/extensions/MockCertificateValidator.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../../common";
+
+export interface MockCertificateValidatorInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "validateControllerCertificate"
+      | "validateTokenCertificate"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "validateControllerCertificate",
+    values: [BytesLike, AddressLike, AddressLike[], BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "validateTokenCertificate",
+    values: [
+      BytesLike,
+      BytesLike,
+      AddressLike,
+      AddressLike,
+      BigNumberish,
+      AddressLike[],
+      BigNumberish
+    ]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "validateControllerCertificate",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "validateTokenCertificate",
+    data: BytesLike
+  ): Result;
+}
+
+export interface MockCertificateValidator extends BaseContract {
+  connect(runner?: ContractRunner | null): MockCertificateValidator;
+  waitForDeployment(): Promise<this>;
+
+  interface: MockCertificateValidatorInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  validateControllerCertificate: TypedContractMethod<
+    [
+      controllerData: BytesLike,
+      controller: AddressLike,
+      controllers: AddressLike[],
+      nonce: BigNumberish
+    ],
+    [void],
+    "view"
+  >;
+
+  validateTokenCertificate: TypedContractMethod<
+    [
+      controllerData: BytesLike,
+      partition: BytesLike,
+      from: AddressLike,
+      to: AddressLike,
+      value: BigNumberish,
+      controllers: AddressLike[],
+      nonce: BigNumberish
+    ],
+    [void],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "validateControllerCertificate"
+  ): TypedContractMethod<
+    [
+      controllerData: BytesLike,
+      controller: AddressLike,
+      controllers: AddressLike[],
+      nonce: BigNumberish
+    ],
+    [void],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "validateTokenCertificate"
+  ): TypedContractMethod<
+    [
+      controllerData: BytesLike,
+      partition: BytesLike,
+      from: AddressLike,
+      to: AddressLike,
+      value: BigNumberish,
+      controllers: AddressLike[],
+      nonce: BigNumberish
+    ],
+    [void],
+    "view"
+  >;
+
+  filters: {};
+}

typechain2/contracts/mock/extensions/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { MockCertificateValidator } from "./MockCertificateValidator";

typechain2/contracts/mock/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type * as globalKycMockUpgradeSol from "./GlobalKycMockUpgrade.sol";
+export type { globalKycMockUpgradeSol };
+import type * as extensions from "./extensions";
+export type { extensions };
+export type { MockConnector } from "./MockConnector";
+export type { MockRules } from "./MockRules";
+export type { MockSecurityToken } from "./MockSecurityToken";

typechain2/contracts/partitions/IPartitions.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export declare namespace IPartitions {
+  export type VariableStruct = { key: BytesLike; kind: string };
+
+  export type VariableStructOutput = [key: string, kind: string] & {
+    key: string;
+    kind: string;
+  };
+}
+
+export interface IPartitionsInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "getValue"
+      | "getVariables"
+      | "isKey"
+      | "isPartition"
+      | "removePartition"
+      | "setPartition"
+      | "setValues"
+      | "setVariables"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "PartitionRemoved"
+      | "PartitionSet"
+      | "TokenSet"
+      | "ValueRemoved"
+      | "ValueSet"
+      | "VariableSet"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "getValue",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVariables",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "isKey", values: [BytesLike]): string;
+  encodeFunctionData(
+    functionFragment: "isPartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removePartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setPartition",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setValues",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setVariables",
+    values: [IPartitions.VariableStruct[]]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "getValue", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getVariables",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "isKey", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removePartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "setValues", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setVariables",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace PartitionRemovedEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionSetEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenSetEvent {
+  export type InputTuple = [token: AddressLike];
+  export type OutputTuple = [token: string];
+  export interface OutputObject {
+    token: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueRemovedEvent {
+  export type InputTuple = [partition: BytesLike, key: BytesLike];
+  export type OutputTuple = [partition: string, key: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueSetEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    key: BytesLike,
+    value: BytesLike
+  ];
+  export type OutputTuple = [partition: string, key: string, value: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+    value: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace VariableSetEvent {
+  export type InputTuple = [key: BytesLike, kind: string];
+  export type OutputTuple = [key: string, kind: string];
+  export interface OutputObject {
+    key: string;
+    kind: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface IPartitions extends BaseContract {
+  connect(runner?: ContractRunner | null): IPartitions;
+  waitForDeployment(): Promise<this>;
+
+  interface: IPartitionsInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  getValue: TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getVariables: TypedContractMethod<
+    [],
+    [IPartitions.VariableStructOutput[]],
+    "view"
+  >;
+
+  isKey: TypedContractMethod<[key: BytesLike], [boolean], "view">;
+
+  isPartition: TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+
+  removePartition: TypedContractMethod<
+    [partition: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setPartition: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setValues: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setVariables: TypedContractMethod<
+    [newVariables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "getValue"
+  ): TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getVariables"
+  ): TypedContractMethod<[], [IPartitions.VariableStructOutput[]], "view">;
+  getFunction(
+    nameOrSignature: "isKey"
+  ): TypedContractMethod<[key: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isPartition"
+  ): TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "removePartition"
+  ): TypedContractMethod<[partition: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setPartition"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setValues"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setVariables"
+  ): TypedContractMethod<
+    [newVariables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "PartitionRemoved"
+  ): TypedContractEvent<
+    PartitionRemovedEvent.InputTuple,
+    PartitionRemovedEvent.OutputTuple,
+    PartitionRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionSet"
+  ): TypedContractEvent<
+    PartitionSetEvent.InputTuple,
+    PartitionSetEvent.OutputTuple,
+    PartitionSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenSet"
+  ): TypedContractEvent<
+    TokenSetEvent.InputTuple,
+    TokenSetEvent.OutputTuple,
+    TokenSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueRemoved"
+  ): TypedContractEvent<
+    ValueRemovedEvent.InputTuple,
+    ValueRemovedEvent.OutputTuple,
+    ValueRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueSet"
+  ): TypedContractEvent<
+    ValueSetEvent.InputTuple,
+    ValueSetEvent.OutputTuple,
+    ValueSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "VariableSet"
+  ): TypedContractEvent<
+    VariableSetEvent.InputTuple,
+    VariableSetEvent.OutputTuple,
+    VariableSetEvent.OutputObject
+  >;
+
+  filters: {
+    "PartitionRemoved(bytes32)": TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+    PartitionRemoved: TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+
+    "PartitionSet(bytes32)": TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+    PartitionSet: TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+
+    "TokenSet(address)": TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+    TokenSet: TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+
+    "ValueRemoved(bytes32,bytes32)": TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+    ValueRemoved: TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+
+    "ValueSet(bytes32,bytes32,bytes32)": TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+    ValueSet: TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+
+    "VariableSet(bytes32,string)": TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+    VariableSet: TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/partitions/Partitions.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export declare namespace IPartitions {
+  export type VariableStruct = { key: BytesLike; kind: string };
+
+  export type VariableStructOutput = [key: string, kind: string] & {
+    key: string;
+    kind: string;
+  };
+
+  export type PartitionStruct = { name: BytesLike; data: BytesLike };
+
+  export type PartitionStructOutput = [name: string, data: string] & {
+    name: string;
+    data: string;
+  };
+}
+
+export interface PartitionsInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "ISSUER_ROLE"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "getValue"
+      | "getVariables"
+      | "hasRole"
+      | "initialize"
+      | "isIssuer"
+      | "isKey"
+      | "isPartition"
+      | "issuers"
+      | "partitions"
+      | "removePartition"
+      | "setPartition"
+      | "setValues"
+      | "setVariables"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "PartitionRemoved"
+      | "PartitionSet"
+      | "RoleGranted"
+      | "RoleRevoked"
+      | "TokenSet"
+      | "ValueRemoved"
+      | "ValueSet"
+      | "VariableSet"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "ISSUER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getValue",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVariables",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values: [IPartitions.PartitionStruct[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isIssuer",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "isKey", values: [BytesLike]): string;
+  encodeFunctionData(
+    functionFragment: "isPartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "issuers", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "partitions",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removePartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setPartition",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setValues",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setVariables",
+    values: [IPartitions.VariableStruct[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "ISSUER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getValue", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getVariables",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isIssuer", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isKey", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "issuers", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "partitions", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "removePartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "setValues", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setVariables",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionRemovedEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionSetEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenSetEvent {
+  export type InputTuple = [token: AddressLike];
+  export type OutputTuple = [token: string];
+  export interface OutputObject {
+    token: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueRemovedEvent {
+  export type InputTuple = [partition: BytesLike, key: BytesLike];
+  export type OutputTuple = [partition: string, key: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueSetEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    key: BytesLike,
+    value: BytesLike
+  ];
+  export type OutputTuple = [partition: string, key: string, value: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+    value: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace VariableSetEvent {
+  export type InputTuple = [key: BytesLike, kind: string];
+  export type OutputTuple = [key: string, kind: string];
+  export interface OutputObject {
+    key: string;
+    kind: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Partitions extends BaseContract {
+  connect(runner?: ContractRunner | null): Partitions;
+  waitForDeployment(): Promise<this>;
+
+  interface: PartitionsInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  ISSUER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getValue: TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getVariables: TypedContractMethod<
+    [],
+    [IPartitions.VariableStructOutput[]],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  initialize: TypedContractMethod<
+    [initialPartitions: IPartitions.PartitionStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  isIssuer: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isKey: TypedContractMethod<[key: BytesLike], [boolean], "view">;
+
+  isPartition: TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+
+  issuers: TypedContractMethod<[], [string[]], "view">;
+
+  partitions: TypedContractMethod<[], [string[]], "view">;
+
+  removePartition: TypedContractMethod<
+    [partition: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setPartition: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setValues: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setVariables: TypedContractMethod<
+    [variables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "ISSUER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getValue"
+  ): TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getVariables"
+  ): TypedContractMethod<[], [IPartitions.VariableStructOutput[]], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<
+    [initialPartitions: IPartitions.PartitionStruct[]],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "isIssuer"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isKey"
+  ): TypedContractMethod<[key: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isPartition"
+  ): TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issuers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "partitions"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "removePartition"
+  ): TypedContractMethod<[partition: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setPartition"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setValues"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setVariables"
+  ): TypedContractMethod<
+    [variables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionRemoved"
+  ): TypedContractEvent<
+    PartitionRemovedEvent.InputTuple,
+    PartitionRemovedEvent.OutputTuple,
+    PartitionRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionSet"
+  ): TypedContractEvent<
+    PartitionSetEvent.InputTuple,
+    PartitionSetEvent.OutputTuple,
+    PartitionSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenSet"
+  ): TypedContractEvent<
+    TokenSetEvent.InputTuple,
+    TokenSetEvent.OutputTuple,
+    TokenSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueRemoved"
+  ): TypedContractEvent<
+    ValueRemovedEvent.InputTuple,
+    ValueRemovedEvent.OutputTuple,
+    ValueRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueSet"
+  ): TypedContractEvent<
+    ValueSetEvent.InputTuple,
+    ValueSetEvent.OutputTuple,
+    ValueSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "VariableSet"
+  ): TypedContractEvent<
+    VariableSetEvent.InputTuple,
+    VariableSetEvent.OutputTuple,
+    VariableSetEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "PartitionRemoved(bytes32)": TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+    PartitionRemoved: TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+
+    "PartitionSet(bytes32)": TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+    PartitionSet: TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+
+    "TokenSet(address)": TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+    TokenSet: TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+
+    "ValueRemoved(bytes32,bytes32)": TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+    ValueRemoved: TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+
+    "ValueSet(bytes32,bytes32,bytes32)": TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+    ValueSet: TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+
+    "VariableSet(bytes32,string)": TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+    VariableSet: TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/partitions/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IPartitions } from "./IPartitions";
+export type { Partitions } from "./Partitions";

typechain2/contracts/rules/IRules.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface IRulesInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "canCreateLockByPartition"
+      | "canIssueByPartition"
+      | "canRedeem"
+      | "canRedeemByPartition"
+      | "canTransferByPartition"
+      | "canTransferByPartitions"
+      | "canTransferFrom"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "canCreateLockByPartition",
+    values: [AddressLike, BytesLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canIssueByPartition",
+    values: [BytesLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeem",
+    values: [AddressLike, BigNumberish, BytesLike[], BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeemByPartition",
+    values: [AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartition",
+    values: [AddressLike, AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartitions",
+    values: [
+      AddressLike,
+      AddressLike,
+      BytesLike,
+      BytesLike,
+      BigNumberish,
+      BytesLike
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferFrom",
+    values: [AddressLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "canCreateLockByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canIssueByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "canRedeem", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "canRedeemByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartitions",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferFrom",
+    data: BytesLike
+  ): Result;
+}
+
+export interface IRules extends BaseContract {
+  connect(runner?: ContractRunner | null): IRules;
+  waitForDeployment(): Promise<this>;
+
+  interface: IRulesInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  canCreateLockByPartition: TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [[string, string]],
+    "view"
+  >;
+
+  canIssueByPartition: TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canRedeem: TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      data: BytesLike
+    ],
+    [[string, string]],
+    "view"
+  >;
+
+  canRedeemByPartition: TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canTransferByPartition: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canTransferByPartitions: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string, string]],
+    "view"
+  >;
+
+  canTransferFrom: TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, data: BytesLike],
+    [[string, string]],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "canCreateLockByPartition"
+  ): TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canIssueByPartition"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeem"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      data: BytesLike
+    ],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeemByPartition"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartition"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartitions"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      data: BytesLike
+    ],
+    [[string, string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferFrom"
+  ): TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, data: BytesLike],
+    [[string, string]],
+    "view"
+  >;
+
+  filters: {};
+}

typechain2/contracts/rules/Rules.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export declare namespace IPartitions {
+  export type VariableStruct = { key: BytesLike; kind: string };
+
+  export type VariableStructOutput = [key: string, kind: string] & {
+    key: string;
+    kind: string;
+  };
+
+  export type PartitionStruct = { name: BytesLike; data: BytesLike };
+
+  export type PartitionStructOutput = [name: string, data: string] & {
+    name: string;
+    data: string;
+  };
+}
+
+export interface RulesInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "CONTROLLER_ROLE"
+      | "ISSUER_ROLE"
+      | "canCreateLockByPartition"
+      | "canIssueByPartition"
+      | "canRedeem"
+      | "canRedeemByPartition"
+      | "canTransferByPartition"
+      | "canTransferByPartitions"
+      | "canTransferFrom"
+      | "controllers"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "getSelectors"
+      | "getValue"
+      | "getVariables"
+      | "hasRole"
+      | "initialize"
+      | "isController"
+      | "isIssuer"
+      | "isKey"
+      | "isPartition"
+      | "issuers"
+      | "numOfControllers"
+      | "partitions"
+      | "removePartition"
+      | "setPartition"
+      | "setValues"
+      | "setVariables"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "PartitionRemoved"
+      | "PartitionSet"
+      | "RoleGranted"
+      | "RoleRevoked"
+      | "TokenSet"
+      | "ValueRemoved"
+      | "ValueSet"
+      | "VariableSet"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "CONTROLLER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "ISSUER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canCreateLockByPartition",
+    values: [AddressLike, BytesLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canIssueByPartition",
+    values: [BytesLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeem",
+    values: [AddressLike, BigNumberish, BytesLike[], BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canRedeemByPartition",
+    values: [AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartition",
+    values: [AddressLike, AddressLike, BytesLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferByPartitions",
+    values: [
+      AddressLike,
+      AddressLike,
+      BytesLike,
+      BytesLike,
+      BigNumberish,
+      BytesLike
+    ]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "canTransferFrom",
+    values: [AddressLike, AddressLike, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "controllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembers",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getRoleMembersLength",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getSelectors",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getValue",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getVariables",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "hasRole",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "initialize",
+    values: [IPartitions.PartitionStruct[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isController",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isIssuer",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "isKey", values: [BytesLike]): string;
+  encodeFunctionData(
+    functionFragment: "isPartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(functionFragment: "issuers", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "numOfControllers",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "partitions",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removePartition",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setPartition",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setValues",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setVariables",
+    values: [IPartitions.VariableStruct[]]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "CONTROLLER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "ISSUER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canCreateLockByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canIssueByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "canRedeem", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "canRedeemByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferByPartitions",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "canTransferFrom",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "controllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getRoleMembersLength",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getSelectors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "getValue", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getVariables",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isController",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "isIssuer", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isKey", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "isPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "issuers", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "numOfControllers",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "partitions", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "removePartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "setValues", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setVariables",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace InitializedEvent {
+  export type InputTuple = [version: BigNumberish];
+  export type OutputTuple = [version: bigint];
+  export interface OutputObject {
+    version: bigint;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionRemovedEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace PartitionSetEvent {
+  export type InputTuple = [partition: BytesLike];
+  export type OutputTuple = [partition: string];
+  export interface OutputObject {
+    partition: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleGrantedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace RoleRevokedEvent {
+  export type InputTuple = [role: BytesLike, account: AddressLike];
+  export type OutputTuple = [role: string, account: string];
+  export interface OutputObject {
+    role: string;
+    account: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace TokenSetEvent {
+  export type InputTuple = [token: AddressLike];
+  export type OutputTuple = [token: string];
+  export interface OutputObject {
+    token: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueRemovedEvent {
+  export type InputTuple = [partition: BytesLike, key: BytesLike];
+  export type OutputTuple = [partition: string, key: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace ValueSetEvent {
+  export type InputTuple = [
+    partition: BytesLike,
+    key: BytesLike,
+    value: BytesLike
+  ];
+  export type OutputTuple = [partition: string, key: string, value: string];
+  export interface OutputObject {
+    partition: string;
+    key: string;
+    value: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace VariableSetEvent {
+  export type InputTuple = [key: BytesLike, kind: string];
+  export type OutputTuple = [key: string, kind: string];
+  export interface OutputObject {
+    key: string;
+    kind: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Rules extends BaseContract {
+  connect(runner?: ContractRunner | null): Rules;
+  waitForDeployment(): Promise<this>;
+
+  interface: RulesInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  CONTROLLER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  ISSUER_ROLE: TypedContractMethod<[], [string], "view">;
+
+  canCreateLockByPartition: TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [[string, string]],
+    "view"
+  >;
+
+  canIssueByPartition: TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canRedeem: TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      arg3: BytesLike
+    ],
+    [[string, string]],
+    "view"
+  >;
+
+  canRedeemByPartition: TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canTransferByPartition: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg4: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+
+  canTransferByPartitions: TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      arg5: BytesLike
+    ],
+    [[string, string, string, string]],
+    "view"
+  >;
+
+  canTransferFrom: TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, arg3: BytesLike],
+    [[string, string]],
+    "view"
+  >;
+
+  controllers: TypedContractMethod<[], [string[]], "view">;
+
+  getRoleMembers: TypedContractMethod<[role: BytesLike], [string[]], "view">;
+
+  getRoleMembersLength: TypedContractMethod<
+    [role: BytesLike],
+    [bigint],
+    "view"
+  >;
+
+  getSelectors: TypedContractMethod<[], [string], "view">;
+
+  getValue: TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getVariables: TypedContractMethod<
+    [],
+    [IPartitions.VariableStructOutput[]],
+    "view"
+  >;
+
+  hasRole: TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+
+  initialize: TypedContractMethod<
+    [initialPartitions: IPartitions.PartitionStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  isController: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isIssuer: TypedContractMethod<[account: AddressLike], [boolean], "view">;
+
+  isKey: TypedContractMethod<[key: BytesLike], [boolean], "view">;
+
+  isPartition: TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+
+  issuers: TypedContractMethod<[], [string[]], "view">;
+
+  numOfControllers: TypedContractMethod<[], [bigint], "view">;
+
+  partitions: TypedContractMethod<[], [string[]], "view">;
+
+  removePartition: TypedContractMethod<
+    [partition: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setPartition: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setValues: TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+
+  setVariables: TypedContractMethod<
+    [variables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "CONTROLLER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "ISSUER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "canCreateLockByPartition"
+  ): TypedContractMethod<
+    [holder: AddressLike, partition: BytesLike, value: BigNumberish],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canIssueByPartition"
+  ): TypedContractMethod<
+    [
+      partition: BytesLike,
+      tokenHolder: AddressLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeem"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      value: BigNumberish,
+      defaultPartitions: BytesLike[],
+      arg3: BytesLike
+    ],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canRedeemByPartition"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg3: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartition"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      partition: BytesLike,
+      value: BigNumberish,
+      arg4: BytesLike
+    ],
+    [[string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferByPartitions"
+  ): TypedContractMethod<
+    [
+      from: AddressLike,
+      to: AddressLike,
+      fromPartition: BytesLike,
+      toPartition: BytesLike,
+      value: BigNumberish,
+      arg5: BytesLike
+    ],
+    [[string, string, string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "canTransferFrom"
+  ): TypedContractMethod<
+    [from: AddressLike, to: AddressLike, value: BigNumberish, arg3: BytesLike],
+    [[string, string]],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "controllers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembers"
+  ): TypedContractMethod<[role: BytesLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "getRoleMembersLength"
+  ): TypedContractMethod<[role: BytesLike], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "getSelectors"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "getValue"
+  ): TypedContractMethod<
+    [partition: BytesLike, key: BytesLike],
+    [string],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getVariables"
+  ): TypedContractMethod<[], [IPartitions.VariableStructOutput[]], "view">;
+  getFunction(
+    nameOrSignature: "hasRole"
+  ): TypedContractMethod<
+    [role: BytesLike, account: AddressLike],
+    [boolean],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "initialize"
+  ): TypedContractMethod<
+    [initialPartitions: IPartitions.PartitionStruct[]],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "isController"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isIssuer"
+  ): TypedContractMethod<[account: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isKey"
+  ): TypedContractMethod<[key: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "isPartition"
+  ): TypedContractMethod<[partition: BytesLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "issuers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "numOfControllers"
+  ): TypedContractMethod<[], [bigint], "view">;
+  getFunction(
+    nameOrSignature: "partitions"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "removePartition"
+  ): TypedContractMethod<[partition: BytesLike], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "setPartition"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setValues"
+  ): TypedContractMethod<
+    [partition: BytesLike, data: BytesLike],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "setVariables"
+  ): TypedContractMethod<
+    [variables: IPartitions.VariableStruct[]],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "Initialized"
+  ): TypedContractEvent<
+    InitializedEvent.InputTuple,
+    InitializedEvent.OutputTuple,
+    InitializedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionRemoved"
+  ): TypedContractEvent<
+    PartitionRemovedEvent.InputTuple,
+    PartitionRemovedEvent.OutputTuple,
+    PartitionRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "PartitionSet"
+  ): TypedContractEvent<
+    PartitionSetEvent.InputTuple,
+    PartitionSetEvent.OutputTuple,
+    PartitionSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleGranted"
+  ): TypedContractEvent<
+    RoleGrantedEvent.InputTuple,
+    RoleGrantedEvent.OutputTuple,
+    RoleGrantedEvent.OutputObject
+  >;
+  getEvent(
+    key: "RoleRevoked"
+  ): TypedContractEvent<
+    RoleRevokedEvent.InputTuple,
+    RoleRevokedEvent.OutputTuple,
+    RoleRevokedEvent.OutputObject
+  >;
+  getEvent(
+    key: "TokenSet"
+  ): TypedContractEvent<
+    TokenSetEvent.InputTuple,
+    TokenSetEvent.OutputTuple,
+    TokenSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueRemoved"
+  ): TypedContractEvent<
+    ValueRemovedEvent.InputTuple,
+    ValueRemovedEvent.OutputTuple,
+    ValueRemovedEvent.OutputObject
+  >;
+  getEvent(
+    key: "ValueSet"
+  ): TypedContractEvent<
+    ValueSetEvent.InputTuple,
+    ValueSetEvent.OutputTuple,
+    ValueSetEvent.OutputObject
+  >;
+  getEvent(
+    key: "VariableSet"
+  ): TypedContractEvent<
+    VariableSetEvent.InputTuple,
+    VariableSetEvent.OutputTuple,
+    VariableSetEvent.OutputObject
+  >;
+
+  filters: {
+    "Initialized(uint64)": TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+    Initialized: TypedContractEvent<
+      InitializedEvent.InputTuple,
+      InitializedEvent.OutputTuple,
+      InitializedEvent.OutputObject
+    >;
+
+    "PartitionRemoved(bytes32)": TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+    PartitionRemoved: TypedContractEvent<
+      PartitionRemovedEvent.InputTuple,
+      PartitionRemovedEvent.OutputTuple,
+      PartitionRemovedEvent.OutputObject
+    >;
+
+    "PartitionSet(bytes32)": TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+    PartitionSet: TypedContractEvent<
+      PartitionSetEvent.InputTuple,
+      PartitionSetEvent.OutputTuple,
+      PartitionSetEvent.OutputObject
+    >;
+
+    "RoleGranted(bytes32,address)": TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+    RoleGranted: TypedContractEvent<
+      RoleGrantedEvent.InputTuple,
+      RoleGrantedEvent.OutputTuple,
+      RoleGrantedEvent.OutputObject
+    >;
+
+    "RoleRevoked(bytes32,address)": TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+    RoleRevoked: TypedContractEvent<
+      RoleRevokedEvent.InputTuple,
+      RoleRevokedEvent.OutputTuple,
+      RoleRevokedEvent.OutputObject
+    >;
+
+    "TokenSet(address)": TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+    TokenSet: TypedContractEvent<
+      TokenSetEvent.InputTuple,
+      TokenSetEvent.OutputTuple,
+      TokenSetEvent.OutputObject
+    >;
+
+    "ValueRemoved(bytes32,bytes32)": TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+    ValueRemoved: TypedContractEvent<
+      ValueRemovedEvent.InputTuple,
+      ValueRemovedEvent.OutputTuple,
+      ValueRemovedEvent.OutputObject
+    >;
+
+    "ValueSet(bytes32,bytes32,bytes32)": TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+    ValueSet: TypedContractEvent<
+      ValueSetEvent.InputTuple,
+      ValueSetEvent.OutputTuple,
+      ValueSetEvent.OutputObject
+    >;
+
+    "VariableSet(bytes32,string)": TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+    VariableSet: TypedContractEvent<
+      VariableSetEvent.InputTuple,
+      VariableSetEvent.OutputTuple,
+      VariableSetEvent.OutputObject
+    >;
+  };
+}

typechain2/contracts/rules/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { IRules } from "./IRules";
+export type { Rules } from "./Rules";

typechain2/factories/@openzeppelin/contracts-upgradeable/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as proxy from "./proxy";

typechain2/factories/@openzeppelin/contracts-upgradeable/proxy/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as utils from "./utils";

typechain2/factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Interface, type ContractRunner } from "ethers";
+import type {
+  Initializable,
+  InitializableInterface,
+} from "../../../../../@openzeppelin/contracts-upgradeable/proxy/utils/Initializable";
+
+const _abi = [
+  {
+    inputs: [],
+    name: "InvalidInitialization",
+    type: "error",
+  },
+  {
+    inputs: [],
+    name: "NotInitializing",
+    type: "error",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint64",
+        name: "version",
+        type: "uint64",
+      },
+    ],
+    name: "Initialized",
+    type: "event",
+  },
+] as const;
+
+export class Initializable__factory {
+  static readonly abi = _abi;
+  static createInterface(): InitializableInterface {
+    return new Interface(_abi) as InitializableInterface;
+  }
+  static connect(
+    address: string,
+    runner?: ContractRunner | null
+  ): Initializable {
+    return new Contract(address, _abi, runner) as unknown as Initializable;
+  }
+}

typechain2/factories/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { Initializable__factory } from "./Initializable__factory";

typechain2/factories/@openzeppelin/contracts/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as proxy from "./proxy";
+export * as utils from "./utils";

typechain2/factories/@openzeppelin/contracts/proxy/beacon/IBeacon__factory.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, Interface, type ContractRunner } from "ethers";
+import type {
+  IBeacon,
+  IBeaconInterface,
+} from "../../../../../@openzeppelin/contracts/proxy/beacon/IBeacon";
+
+const _abi = [
+  {
+    inputs: [],
+    name: "implementation",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class IBeacon__factory {
+  static readonly abi = _abi;
+  static createInterface(): IBeaconInterface {
+    return new Interface(_abi) as IBeaconInterface;
+  }
+  static connect(address: string, runner?: ContractRunner | null): IBeacon {
+    return new Contract(address, _abi, runner) as unknown as IBeacon;
+  }
+}

typechain2/factories/@openzeppelin/contracts/proxy/beacon/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { IBeacon__factory } from "./IBeacon__factory";

typechain2/factories/@openzeppelin/contracts/proxy/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as beacon from "./beacon";

typechain2/factories/@openzeppelin/contracts/utils/Strings__factory.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  Contract,
+  ContractFactory,
+  ContractTransactionResponse,
+  Interface,
+} from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../../common";
+import type {
+  Strings,
+  StringsInterface,
+} from "../../../../@openzeppelin/contracts/utils/Strings";
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+      {
+        internalType: "uint256",
+        name: "length",
+        type: "uint256",
+      },
+    ],
+    name: "StringsInsufficientHexLength",
+    type: "error",
+  },
+] as const;
+
+const _bytecode =
+  "0x60808060405234601757603a9081601d823930815050f35b600080fdfe600080fdfea2646970667358221220e0e7c672dca5949bbee5da6aca32344b7ca8fd5bee2a9e6b33aad6a86b230d8c64736f6c63430008140033";
+
+type StringsConstructorParams =
+  | [signer?: Signer]
+  | ConstructorParameters<typeof ContractFactory>;
+
+const isSuperArgs = (
+  xs: StringsConstructorParams
+): xs is ConstructorParameters<typeof ContractFactory> => xs.length > 1;
+
+export class Strings__factory extends ContractFactory {
+  constructor(...args: StringsConstructorParams) {
+    if (isSuperArgs(args)) {
+      super(...args);
+    } else {
+      super(_abi, _bytecode, args[0]);
+    }
+  }
+
+  override getDeployTransaction(
+    overrides?: NonPayableOverrides & { from?: string }
+  ): Promise<ContractDeployTransaction> {
+    return super.getDeployTransaction(overrides || {});
+  }
+  override deploy(overrides?: NonPayableOverrides & { from?: string }) {
+    return super.deploy(overrides || {}) as Promise<
+      Strings & {
+        deploymentTransaction(): ContractTransactionResponse;
+      }
+    >;
+  }
+  override connect(runner: ContractRunner | null): Strings__factory {
+    return super.connect(runner) as Strings__factory;
+  }
+
+  static readonly bytecode = _bytecode;
+  static readonly abi = _abi;
+  static createInterface(): StringsInterface {
+    return new Interface(_abi) as StringsInterface;
+  }
+  static connect(address: string, runner?: ContractRunner | null): Strings {
+    return new Contract(address, _abi, runner) as unknown as Strings;
+  }
+}

typechain2/factories/@openzeppelin/contracts/utils/cryptography/ECDSA__factory.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  Contract,
+  ContractFactory,
+  ContractTransactionResponse,
+  Interface,
+} from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../../../common";
+import type {
+  ECDSA,
+  ECDSAInterface,
+} from "../../../../../@openzeppelin/contracts/utils/cryptography/ECDSA";
+
+const _abi = [
+  {
+    inputs: [],
+    name: "ECDSAInvalidSignature",
+    type: "error",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "length",
+        type: "uint256",
+      },
+    ],
+    name: "ECDSAInvalidSignatureLength",
+    type: "error",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "s",
+        type: "bytes32",
+      },
+    ],
+    name: "ECDSAInvalidSignatureS",
+    type: "error",
+  },
+] as const;
+
+const _bytecode =
+  "0x60808060405234601757603a9081601d823930815050f35b600080fdfe600080fdfea2646970667358221220afa2a05a95a48520d77a56f00e2afdc374d077d8fdb6f9645e07e1d83ff79c6c64736f6c63430008140033";
+
+type ECDSAConstructorParams =
+  | [signer?: Signer]
+  | ConstructorParameters<typeof ContractFactory>;
+
+const isSuperArgs = (
+  xs: ECDSAConstructorParams
+): xs is ConstructorParameters<typeof ContractFactory> => xs.length > 1;
+
+export class ECDSA__factory extends ContractFactory {
+  constructor(...args: ECDSAConstructorParams) {
+    if (isSuperArgs(args)) {
+      super(...args);
+    } else {
+      super(_abi, _bytecode, args[0]);
+    }
+  }
+
+  override getDeployTransaction(
+    overrides?: NonPayableOverrides & { from?: string }
+  ): Promise<ContractDeployTransaction> {
+    return super.getDeployTransaction(overrides || {});
+  }
+  override deploy(overrides?: NonPayableOverrides & { from?: string }) {
+    return super.deploy(overrides || {}) as Promise<
+      ECDSA & {
+        deploymentTransaction(): ContractTransactionResponse;
+      }
+    >;
+  }
+  override connect(runner: ContractRunner | null): ECDSA__factory {
+    return super.connect(runner) as ECDSA__factory;
+  }
+
+  static readonly bytecode = _bytecode;
+  static readonly abi = _abi;
+  static createInterface(): ECDSAInterface {
+    return new Interface(_abi) as ECDSAInterface;
+  }
+  static connect(address: string, runner?: ContractRunner | null): ECDSA {
+    return new Contract(address, _abi, runner) as unknown as ECDSA;
+  }
+}

typechain2/factories/@openzeppelin/contracts/utils/cryptography/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { ECDSA__factory } from "./ECDSA__factory";

typechain2/factories/@openzeppelin/contracts/utils/index.ts

+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as cryptography from "./cryptography";
+export * as math from "./math";
+export { Strings__factory } from "./Strings__factory";