w

.env

+#besu info
+
+#localhost
+# RPCURL=http://localhost:8545
+# CHAINID=1337
+
+#OCI
+RPCURL=http://193.123.252.127:80
+CHAINID=1337
+

.gitignore

+node_modules
+blockchain-info
+sys-info

1.1_SystemInfo.sh

+#!/bin/bash
+. ./inc/utils.sh
+
+
+mkdir -p sys-info
+
+cat /proc/cpuinfo > sys-info/cpu.txt
+free -h > sys-info/mem.txt
+df -h > sys-info/disk.txt
+
+echo "sys-info 폴더에 정보를 저장했습니다..."

1.3_Ntpstat.sh

+#!/bin/bash
+. ./inc/utils.sh
+
+
+mkdir -p sys-info
+
+ntpstat > ./sys-info/ntpstat.txt

1.4_Blockchain_version.sh

+#!/bin/bash
+. ./inc/utils.sh
+
+NS=besu
+POD=besu-node-validator-1-0
+
+mkdir -p blockchain-info
+
+# kubectl describe pod $POD -n $NS > blockchain-info/$POD-info.txt
+# kubectl describe configmap besu-genesis -n $NS > blockchain-info/genesis-info.txt
+
+# save genesis.json configmap to genesis.json
+echo "saving genesis.json configmap to genesis.json"
+CM=$(kubectl describe configmap besu-genesis -n $NS)
+CM=${CM#*----}
+CM=${CM%BinaryData*}
+
+echo $CM > ./blockchain-info/genesis.json
+
+echo $(kubectl get secrets/besu-node-validator-1-keys -o json -n besu) > ./blockchain-info/validator1.secret.json
+

1.4_Blockchain_version.ts

+import * as fs from 'fs';
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, ethers ,Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    decodeBase64
+} from 'ethers'
+
+// const chainRpc = 'http://193.123.252.127';
+// const port = ':80';
+const chainRpc = 'http://localhost';
+const port = ':21001';
+
+// const chainRpc = 'http://10.96.35.108';
+// const port = ':8545';
+
+const rpcUrl = chainRpc + port;
+const provider = new JsonRpcProvider(rpcUrl);
+
+
+async function getValidators(): Promise<any> {
+    const url = rpcUrl;
+    const res = await fetch(url,{
+        method: 'POST',
+        headers: { 
+            'Content-Type' :'application/json',
+        },
+        body: JSON.stringify({  
+            jsonrpc: "2.0",
+            id: 1,
+            method: "qbft_getValidatorsByBlockNumber",
+            params: ["latest"]
+        })
+    });
+
+    const json = await res.json();
+    // console.log(await res.json());
+
+    return json;
+}
+
+async function getBlockNumber(validatorAddress: string) : Promise<number> {
+
+    //eth_blockNumber
+    const url = rpcUrl;
+    const res = await fetch(url,{
+        method: 'POST',
+        headers: { 
+            'Content-Type' :'application/json',
+        },
+        body: JSON.stringify({  
+            jsonrpc: "2.0",
+            id: 1,
+            method: "eth_blockNumber",
+            params: [""]
+        })
+    });
+
+    const json = await res.json();
+    //console.log(await res.json());
+
+    return json.result;
+
+    return 0;
+}
+
+async function getAddress(privateKey: string): Promise<string> {
+
+    const wallet = new Wallet(privateKey, provider);
+    return wallet.address;
+}
+
+
+
+const genesisFile = './blockchain-info/genesis.json';
+const secretsFile = './blockchain-info/validator1.secret.json';
+async function main() {
+
+    // let json = fs.readFileSync(genesisFile);
+    // const genesis = JSON.parse(json.toString());
+    // console.log('genesis.json 정보')
+    // console.log('genesis.config = ')
+    // console.log(genesis.config);
+    // console.log(`최대 블록 크기 (gasLimit) : ${genesis.gasLimit}`);
+
+    // // 벨리데이터 노드 어드레스 가져오기
+    // const validators = (await getValidators()).result;
+    // console.log(validators);
+    
+    // // validator 1 노드의 노드키에서 유도된 주소를 확인 (벨리데이터 노드의 주소목록에 있는지 확인)
+    // json = fs.readFileSync(secretsFile);
+    // const secrets = JSON.parse(json.toString());
+    // let nodeAddress = Buffer.from(secrets.data.nodekey,'base64').toString('utf8');
+    // nodeAddress = await getAddress(nodeAddress);
+    // console.log(nodeAddress);
+
+    // const found = validators.find((el) => el == nodeAddress.toLowerCase());
+    // console.log(`node address ${found} is found on validators`);
+
+    let bn = await getBlockNumber(chainRpc + '21001');
+    console.log(bn);
+
+    bn = await getBlockNumber(chainRpc + '21002');
+    console.log(bn);
+
+    bn = await getBlockNumber(chainRpc + '21003');
+    console.log(bn);
+
+    bn = await getBlockNumber(chainRpc + '21004');
+    console.log(bn);
+
+}
+
+main();

1.4_CheckBlock.sh

+#!/bin/bash
+
+
+function getBlockNumber() {
+    jsonURL=$1
+    status=`curl -H Content-Type:application/json -d '{"jsonrpc": "2.0", "method": "eth_blockNumber", "id": 1}' -s $jsonURL -m 1`
+    # jq -r 로 "" 스트립
+    ID=`echo $status | jq -r '.["result"]'`
+
+    if [ "$status" == "null" ] || [ "$status" == 0 ]; then
+        echo "get blocknumber failed"
+    else
+        echo $ID
+        printf "블럭 넘버 = %d\n" $ID
+
+        # 다른방식으로 hex값 변환
+        # STRIPED=$(echo $ID |sed -e $'s/0x//g' )
+        # HEX=$((16#$STRIPED))
+        # echo $HEX
+    fi        
+}
+
+kubectl get pods -n besu besu-node-validator-1-0 -o wide
+
+
+echo "Validator1"
+getBlockNumber "http://127.0.0.1:21001"
+echo "Validator2"
+getBlockNumber "http://127.0.0.1:21002"
+echo "Validator3"
+getBlockNumber "http://127.0.0.1:21003"
+echo "Validator4"
+getBlockNumber "http://127.0.0.1:21004"

7.1_validator_stop.sh

+#!/bin/bash
+
+ACT=$1  # stop , run
+if [ -z "$ACT" ]; then
+  echo "동작을 입력하세요. stop, run"
+  exit 1  
+fi
+
+
+mkdir -p temp
+
+if [ "$ACT" == "stop" ]; then
+
+echo "validator 1 을 정지시킨다."
+
+kubectl get statefulset besu-node-validator-1 -o yaml > ./temp/validator1.yaml -n besu
+
+kubectl delete -f ./temp/validator1.yaml
+
+else
+echo "validator 1을 재시작 한다."
+
+kubectl apply -f ./temp/validator1.yaml
+
+
+fi

TC2/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash
+} from 'ethers'
+import {ethers} from 'hardhat';
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import {checkReceipt, setProvider} from '../inc/util'
+
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+
+async function sendTx(fromKey: string, to: string, amount: string, nonce: number): Promise<string> {
+    const wallet = new Wallet(fromKey, provider);
+    const tx = await wallet.sendTransaction({
+        to: to,
+        value: parseUnits(amount, 'ether'),
+        nonce: nonce
+      });
+    return tx.hash;
+}
+
+async function sendDirect(fromKey:string, to: string, amount: string,nonce: number) : Promise<string> {
+    const wallet = new Wallet(fromKey);
+    const sender = wallet.address;
+    // const nonce = await provider.getTransactionCount(sender);
+    // console.log(`block nonce = ${nonce}`);
+
+    const tx = {
+        to: to,
+        value: parseEther(amount.toString()),
+        //gasPrice: 0,
+        //gasPrice: gas,
+        gasLimit: 21000,    //21000으로 고정권장(너무 높으면 속도가 느려짐)
+        //gasLimit: gasLimit,
+        // maxPriorityFeePerGas: parseUnits("5", "gwei"),
+        // maxFeePerGas: parseUnits("20", "gwei"),
+        nonce: nonce,
+        type: 2,
+        chainId: 1337, // Corresponds to ETH_GOERLI
+    };
+    const signed =  await wallet.signTransaction(tx);
+    const txid = await provider.send('eth_sendRawTransaction',[signed]);
+    return txid;
+}
+
+
+async function getBalance(addr: string): Promise<string> {
+    const wallet = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3', provider);
+
+    const balance = await provider.getBalance(addr);
+    return formatEther(balance);
+}
+
+async function getNonce(addr: string): Promise<number> {
+    const nonce = await provider.getTransactionCount(addr);
+    return nonce;
+}
+
+
+
+async function send() {
+    let to = '0xfe3b557e8fb62b89f4916b721be55ceb828dbd73';
+    let from = '0x627306090abaB3A6e1400e9345bC60c78a8BEf57';
+    let fromKey = '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3';
+
+    let nonce = await getNonce(from);
+    let txids = [];
+
+    const count = 1;
+    let startTime = 0;
+
+    for(let i = 0; i < count; i++) {
+        let txid = await sendDirect(fromKey,to,'0.1',nonce++);
+
+        // start time setting
+        if(i == 0) {
+            startTime = Date.now();
+        }
+        // console.log(txid);
+        txids.push({txid});
+    }
+
+    // let txid = await sendTx(to,'0.1',nonce++);
+    await checkReceipt(txids, 'check receipt....');
+
+    let tx = await provider.send('eth_getTransactionByHash',[txids[0].txid]);
+    const firstBlock = await provider.getBlock(tx.blockNumber);
+    // console.log(firstBlock);
+
+
+    tx = await provider.send('eth_getTransactionByHash',[txids[count-1].txid]);
+    const lastBlock = await provider.getBlock(tx.blockNumber);
+    // console.log(lastBlock);
+
+    console.log(startTime);
+    console.log(firstBlock.timestamp);
+    console.log(lastBlock.timestamp);
+
+    // let balance= await getBalance(to);
+    // console.log(balance);
+}
+
+const calc = new Calulator();
+
+async function prepareToken(contractOwner: Wallet | HardhatEthersSigner, issuer: Wallet | HardhatEthersSigner, holder1: string, holder2: string) {
+    const deployed = require('../security_token_deployments.json');
+    const tokenService = new TokenIssuer(contractOwner as Wallet,deployed.tokenBeacon,deployed.rulesBeacon,contractOwner.address);
+    const proxy = await tokenService.deploy('테스트토큰','st0015',6,100000,issuer.address);
+
+    console.log(`new token deployed at ${proxy}`);
+    const token = new SecurityToken__factory(contractOwner).attach(proxy) as SecurityToken;
+    //token.connect(contractOwner);
+    
+    console.log(await token.name());
+    console.log(await token.symbol());
+    console.log(await token.maxSupply());
+    
+    const tokenForIssuer = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+    await tokenForIssuer.connect(issuer);
+    let r = await tokenForIssuer.KYCtokenHolders([holder1]);
+    await tokenForIssuer.KYCtokenHolders([holder2]);
+
+    let txids = [];
+    txids.push({txid: r.hash});
+    await checkReceipt(txids, 'wait for transaction confirmed');
+    
+    const b  = await tokenForIssuer.isTokenHolderKYC(holder1);
+    if(!b) {
+        console.log('holder kyc error');
+        return;
+    }
+
+    await tokenForIssuer.issue(holder1,10_000n,ZeroHash);
+    r = await tokenForIssuer.issue(holder2,5000,ZeroHash);
+
+    txids = [];
+    txids.push({txid: r.hash});
+    await checkReceipt(txids, 'wait for transaction confirmed');
+
+    let balance = await tokenForIssuer.balanceOf(holder1);
+    console.log(`holder1's balance = ${balance}`);
+
+    balance = await tokenForIssuer.balanceOf(holder2);
+    console.log(`holder2's balance = ${balance}`);
+
+    console.log('TestData created!');
+}
+
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+
+
+
+async function main() {
+    setProvider(provider);
+    const admin = await ethers.provider.getSigner(0);
+    const issuer = await ethers.provider.getSigner(1);
+    const holder1 = await ethers.provider.getSigner(2);
+    const holder2 = await ethers.provider.getSigner(3);
+
+    await prepareToken(admin, issuer, holder1.address, holder2.address);
+
+    // await test('0x1411CB266FCEd1587b0AA29E9d5a9Ef3Db64A9C5');
+
+
+}
+
+main();
+
+

TC4/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256
+} from 'ethers'
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+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}`);
+
+async function getNonce(addr: string): Promise<number> {
+    const nonce = await provider.getTransactionCount(addr);
+    return nonce;
+}
+
+async function transfer(symbol:string, count: number = 10) {
+
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+
+    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 token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+    await token.connect(admin);
+    // const ops = await token.operators();
+    // console.log(ops);
+    
+    let balance1= await token.balanceOf(holder1);
+    let balance2 = await token.balanceOf(holder2);
+    const b  = await token.isTokenHolderKYC(holder1);
+    if(!b) {
+        console.log('holder kyc error');
+        return;
+    }
+    const partitions = await token.getDefaultPartitions();
+    console.log(`holder1(sender) = ${balance1}, holder2(receiver) = ${balance2}`);
+    // token.on(token.filters.Transfer, async (...args) => {
+    //     const lastArg = args[args.length - 1];
+    //     console.log(lastArg);
+    //     console.log('on transfer by partition');
+    // })
+
+    
+    let nonce = await getNonce(issuer.address);
+    let txids = [];
+    let proms = [];
+    let firstTx:string = null;
+    let lastTx:string = null;
+    const start = Date.now();
+
+    console.log(`sending ${count} transactions`);
+    for(let i = 0; i < count; i++) {
+        const tx = await token.operatorTransferByPartition.populateTransaction(
+            partitions[0],
+            holder1.address,
+            holder2.address,
+            1,
+            ZeroHash,
+            ZeroHash,
+            {
+                // gasPrice: 0,
+                gasLimit: 2100000,
+                nonce: nonce,
+                type: 2,
+                chainId: 1337
+            }
+        );
+        ++nonce;
+        // console.log(tx);
+
+        const signed =  await issuer.signTransaction(tx);
+        const pm = provider.send('eth_sendRawTransaction',[signed]);
+
+        if(i == 0) {
+            firstTx = keccak256(signed);
+        }
+        if (i == count -1) {
+            lastTx = keccak256(signed);
+        }
+        proms.push(pm);
+    }
+
+    let txs = await Promise.all(proms);
+
+    const elapsed = getElapsed(start,1000);
+    console.log(`all tx sent in ${elapsed} seconds`);
+
+    console.log(`first Tx = ${firstTx}`);
+    console.log(`last Tx = ${lastTx}`);
+    
+    let txMap = new Map<string,boolean>();
+    txs.forEach(txid => {
+        // txids.push({txid: txid});
+        txMap.set(txid,false);
+    });
+    const blockHashes = await checkReceipt2(txMap,[firstTx as string, lastTx as string], 'wait for receipt...');
+
+    const firstBlockHash = blockHashes.get(firstTx);
+    const lastBlockHash = blockHashes.get(lastTx);
+    console.log(`firstBlockHash = ${firstBlockHash} , lastBlockHash = ${lastBlockHash}`);
+
+    const lastB = await getBlockInfo(lastBlockHash);
+    console.log(lastB.timestamp);
+    const lastTimeStamp = parseInt(lastB.timestamp,16);
+
+    balance1= await token.balanceOf(holder1);
+    balance2 = await token.balanceOf(holder2);
+    console.log(`holder1 = ${balance1}, holder2 = ${balance2}`);
+    
+
+    const d = new Date(lastTimeStamp * 1000);
+    console.log(d);
+
+    console.log(start);
+    console.log(lastTimeStamp * 1000);
+
+    const tps = calc.CTPS_NUM(count,start,lastTimeStamp * 1000);
+    console.log(tps);
+
+}
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+
+async function main() {
+    transfer('test001',1000);
+    // for(let i = 13489; i < 13492; i++ ) {
+    //     try {
+    //         await send(i);
+    //     } catch(ex) {
+    //         console.log(ex);
+    //     }
+    //     await sleep(10);
+    // }
+     
+}
+
+main();
+

TC5/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256
+} from 'ethers'
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo,getNonce} from '../inc/util'
+import { assert } from "console";
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+
+
+
+async function readTest(symbol:string, count: number = 100): Promise<any> {
+
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+
+    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 token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+
+
+    let balance1= await token.balanceOf(holder1);
+    let balance2 = await token.balanceOf(holder2);
+
+
+
+    let proms = [];
+    for(let i = 0; i < count; i++)    {
+        proms.push(token.balanceOf(holder1));
+    }
+    
+    let resolved = await Promise.all(proms);
+
+    console.log(resolved.length);
+    assert(count == resolved.length);
+
+    resolved.forEach(balance => {
+        console.log(balance);
+    })
+
+    return 0;
+}
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+console.log(`목적 서버 : ${rpcUrl}`);
+
+async function main() {
+    await readTest('test001');
+}
+
+main();
+

calcCEPS.ts

+// Function to calculate the formula
+function calculateCEPS(N, tFinLatest, tSendEv2) {
+    // Calculate the time difference in milliseconds
+    const timeDifference = tFinLatest - tSendEv2;
+
+    // Ensure timeDifference is not zero to avoid division by zero
+    if (timeDifference === 0) {
+        throw new Error("Time difference cannot be zero.");
+    }
+
+    // Calculate CEPS
+    const CEPS = N / timeDifference;
+    return CEPS;
+}
+
+// Example usage
+const tFinLatest = new Date('2024-11-15T12:00:00Z');  // Replace with actual end time
+const tSendEv2 = new Date('2024-11-15T11:00:00Z');    // Replace with actual send time
+
+try {
+    const result = calculateCEPS(1000, tFinLatest, tSendEv2);
+    console.log("CEPS:", result);
+} catch (error) {
+    console.error(error.message);
+}
+

calcCTPS.ts

+// Define the function to calculate average CTPS
+function calculateAverageCTPS(N, start, end) {
+    // Convert the times to Date objects, if they are not already
+    const startTime = new Date(start);
+    const endTime = new Date(end);
+
+    // Calculate the time difference in seconds
+    const timeDifferenceInSeconds = (endTime.getTime() - startTime.getTime()) / 1000;
+
+    // Calculate the average CTPS
+    const averageCTPS = N / timeDifferenceInSeconds;
+
+    return averageCTPS;
+}
+
+// Example usage
+const count = 1000; // Example number of transactions
+const start = "2023-11-15T08:00:00Z"; // Start time of the first transaction
+const end = "2023-11-15T08:05:00Z"; // Finish time of the latest transaction
+// const tSend_TX1 = new Date('2024-11-15T12:00:00Z');  // Replace with actual end time
+// const tFin_latest_TXk = new Date('2024-11-15T11:00:00Z');    // Replace with actual send time
+
+const result = calculateAverageCTPS(count, start, end);
+console.log("Average CTPS:", result);
+

calcQPS.ts

+// QPS를 계산하는 함수
+function calculateQPS(N, tRecv, tSend) {
+    if (tRecv <= tSend) {
+        throw new Error("Receiving time must be greater than sending time.");
+    }
+    
+    const timeDifference = tRecv - tSend; // 시간 차이 계산 (단위: 초)
+    const QPS = N / timeDifference; // QPS 계산
+    
+    return QPS;
+}
+
+// 예시 데이터 (단위는 초로 가정)
+const N = 5000;               // 전송된 총 데이터량
+const tRecv = 1625140800;      // 데이터 수신 시간 (예: UNIX 타임스탬프)
+const tSend = 1625140500;      // 데이터 송신 시간 (예: UNIX 타임스탬프)
+
+// QPS 계산 및 출력
+try {
+    const QPS = calculateQPS(N, tRecv, tSend);
+    console.log("Calculated QPS:", QPS);
+} catch (error) {
+    console.error(error.message);
+}
+

cmdPod/pilot.yaml

+apiVersion: v1
+kind: Pod
+metadata:
+  name: pilot
+spec:
+  containers:
+    - name: pilot
+      image: ubuntu:latest
+      command: ["sleep"]
+      args: ["infinity"]
+      volumeMounts:
+        - name: data
+          mountPath: /home
+  volumes:
+    - name: data
+      persistentVolumeClaim:
+        claimName: pilot-pvc
+
+# ubuntu command line on the same network space with besu nodes
+# apiVersion: apps/v1
+# kind: Deployment
+# metadata:
+#   name: pilot
+#   labels: {
+#     component: pilot
+#   }
+# spec:
+#   replicas: 1
+#   selector:
+#     matchLabels:
+#       component: pilot
+#   template:
+#     metadata:
+#       labels:
+#         component: pilot
+#   volumes:
+#     - name: data
+#     persistentVolumeClaim:
+#       claimName: pilot-pvc
+#   containers:
+#     - name: pilot
+#       image: ubuntu:latest
+#       command: ["sleep"]
+#       args: ["infinity"]
+#           # volumeMounts:
+#           #   - mountPath: /host
+#           #     name: my-pv-storage
+#           #   - mountPath: /var/run
+#           #     name: host

cmdPod/pv.yaml

+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: pilot-pv
+spec:
+  storageClassName: "oci-bv"
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 50Gi

cmdPod/pvc.yaml

+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: pilot-pvc
+spec:
+  storageClassName: "oci-bv"
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 5Gi

hardhat.config.ts

+import 'dotenv/config';
+import { HardhatUserConfig } from 'hardhat/types';
+// import '@nomicfoundation/hardhat-chai-matchers';
+import '@nomicfoundation/hardhat-ethers';
+import '@nomicfoundation/hardhat-network-helpers';
+import '@nomicfoundation/hardhat-verify';
+import '@openzeppelin/hardhat-upgrades';
+import '@typechain/hardhat';
+import 'hardhat-deploy';
+import 'hardhat-contract-sizer';
+import 'hardhat-gas-reporter';
+import 'solidity-coverage';
+
+const config: HardhatUserConfig = {
+  solidity: {
+    compilers: [
+      {
+        version: '0.8.20',
+        settings: {
+          optimizer: { enabled: true, runs: 50 },
+          viaIR: true,
+        },
+      },
+    ],
+  },
+  typechain: {
+    outDir: 'typechain',
+    target: 'ethers-v6',
+  },
+  paths: {
+    sources: './contracts',
+    tests: './test',
+    cache: './cache',
+    artifacts: './artifacts',
+  },
+  defaultNetwork: 'hardhat',
+  networks: {
+    hardhat: {
+      allowUnlimitedContractSize: true,
+      accounts: {
+        mnemonic: 'test test test test test test test test test test test junk',
+        initialIndex: 0,
+        accountsBalance: '10000000000000000000000000', // 10,000,000 ETH
+      },
+    },
+    besu_on_premise_dev: {
+      chainId: 1337,
+      gas: 'auto',
+      url: 'http://172.25.1.104/',
+      accounts: [
+        '0xccb3131e009c579f16e6088f89218744f670e9b09c28514c671d5ae239f0c532', // admin 0xf1114837ed4a1fA9C03e8CC9F1D74Eb853D69456
+        '0x633942d3d1a3e26d00b45c3141534ce70201ef45a7f770464a51b4843d1fded6', // issuer
+        '0x55d1000aa2057a878b5f7902158615f889cb1e9b811f7e1e9c0b4518399ba84a', // controller
+        '0x60c092d6bdcd9c9ea1afcab4febd2f344b7cde3cdebc99f279b35deaa40b87b7', // controller
+        '0xefb3c2ae169b7521c82fff0f9cf26acae190f11de0532ce3691159e695274b0b',
+        '0xbd426a98e7c9fd367b0a77eb73f5c93df95f24304facfe3f8083ceda371975d2',
+        '0xddc3bd701644512b63fae4934bc0359d346af7f64404786b1ebf6b16fef6dc70',
+        // nonce-manager test accounts (do not use if possible)
+        '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3', // admin 0x627306090abaB3A6e1400e9345bC60c78a8BEf57
+        '0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63', // issuer
+        '0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f', // controller
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', // controller
+      ],
+    },
+    besu_local: {
+      chainId: 1337, 
+      gas: 'auto',
+      url: 'http://localhost:8545' ,
+      accounts: [
+        '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',
+        '0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',
+        '0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      ]
+    },
+    besu_oci: {
+      chainId: 1337, 
+      gas: 'auto',
+      url: 'http://193.123.252.127' ,
+      accounts: [
+        '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',
+        '0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',
+        '0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      ]
+    },
+  },
+  gasReporter: {
+    currency: 'USD',
+    coinmarketcap: process.env.COINMARKETCAP_API_KEY || '',
+    enabled: true,
+  },
+  mocha: {
+    timeout: 60000,
+  },
+};
+
+export default config;

inc/TokenIssuer.ts

+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction, AbiCoder,BigNumberish,ZeroHash
+} from 'ethers'
+import {upgrades, ethers} from 'hardhat';
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+
+import {
+    DEFAULT_DOCUMENTS,
+    DEFAULT_ERC20_DETAILS,
+    DEFAULT_PARTITIONS,
+    DEFAULT_VARIABLES,
+  } from './defaultParameters';
+
+
+
+export class TokenIssuer {
+    
+    wallet: Wallet = null;
+    provider:JsonRpcProvider = null;
+    beaconAddress: string = null;
+    rulesAddress: string = null;
+    tokenOwner: string = null;
+    constructor(wallet: Wallet, beaconAddress: string, rulesAddress: string, tokenOwner: string) {
+        this.wallet = wallet;
+        this.beaconAddress = beaconAddress;
+        this.rulesAddress = rulesAddress;
+        this.tokenOwner = tokenOwner;
+        
+        // console.log(`constructor: \r\nbeacon = ${this.beaconAddress}, \r\nrules = ${this.rulesAddress}, \r\nowner = ${this.tokenOwner}`);
+    }
+
+    async deploy(name:string, symbol:string,decimals: number, maxSupply: number, issuer: string, operators: string[], lockers: string[],controller: string[]): Promise<string> {
+        
+        console.log('deploying token....');
+        
+        const TokenContract = new SecurityToken__factory(this.wallet);
+
+        const proxy = await upgrades.deployBeaconProxy(this.beaconAddress, TokenContract, [
+            this.rulesAddress,
+            issuer,
+            controller,
+            operators,
+            lockers,
+            {
+                name,
+                symbol,
+                decimals,
+                maxSupply
+            },
+            DEFAULT_PARTITIONS.map(p => p.toPartitionStruct()),
+          ]);
+
+        await proxy.waitForDeployment();
+        
+        const proxyAddress = await proxy.getAddress();
+        return proxyAddress;
+    }
+
+    async issue(token: string, holder: string, amount: BigNumberish) {
+
+    }
+}

inc/TokenObject.ts

+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, ethers ,Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther
+} from 'ethers'
+
+// import * as dotevnv from "dotenv"
+// dotevnv.config();
+// if (!process.env.RPCURL) {
+//     console.log(`No rpcur value specified...`)
+// }
+
+
+export class TokenObject {
+
+    _abi;
+
+    constructor() {
+        this._abi = require('./SecurityToken.json');
+    }
+
+}

inc/calc.ts

+import { time } from "console";
+
+
+
+export class Calulator {
+    
+    // timestamp format input
+    CTPS_NUM(count: number, start: number, end: number): number {
+        // Calculate the time difference in milliseconds
+        const timeDifference = (end - start) / 1000;
+        // Ensure timeDifference is not zero to avoid division by zero
+        if (timeDifference === 0) {
+            throw new Error("Time difference cannot be zero.");
+        }
+
+        console.log(`time diff = ${timeDifference}`);
+
+        
+        // Calculate CTPS
+        const CEPS = count / timeDifference;
+        return CEPS;        
+    }
+
+    CTPS(count: number, start: Date, end: Date): number {
+        // Calculate the time difference in milliseconds
+        const timeDifference = end.getTime() - start.getTime();
+        // Ensure timeDifference is not zero to avoid division by zero
+        if (timeDifference === 0) {
+            throw new Error("Time difference cannot be zero.");
+        }
+        // Calculate CTPS
+        const CEPS = count / timeDifference;
+        return CEPS;        
+    }
+
+    CEPS(count: number, start: Date, end: Date): number  {
+        // Calculate the time difference in milliseconds
+    const timeDifference = end.getTime() - start.getTime();
+
+    // Ensure timeDifference is not zero to avoid division by zero
+    if (timeDifference === 0) {
+        throw new Error("Time difference cannot be zero.");
+    }
+
+    // Calculate CEPS
+    const CEPS = count / timeDifference;
+    return CEPS;
+    }
+}
+

inc/defaultParameters.ts

+import { time } from '@nomicfoundation/hardhat-network-helpers';
+import { Document, ERC20Details, Partition, Variable } from './tokenData';
+
+export const DEFAULT_ERC20_DETAILS: ERC20Details = {
+  name: 'Security Token',
+  symbol: 'ST',
+  decimals: 6,
+  maxSupply: 1_000_000,
+};
+
+export const DEFAULT_VARIABLES = [
+  new Variable(
+    'lockup_expiration_transfer',
+    'uint256',
+    // Math.floor(Date.now() / 1000) + time.duration.years(1), // a year from now on
+    Math.floor(Date.now() / 1000) + time.duration.minutes(1), // a year from now on
+  ),
+];
+
+export const DEFAULT_PARTITIONS = [
+  new Partition('DefaultPartition-1', DEFAULT_VARIABLES),
+  new Partition('DefaultPartition-2', DEFAULT_VARIABLES),
+];
+
+export const DEFAULT_DOCUMENTS = [
+  new Document('DefaultDocument-1', 'https://bcg/documents/'),
+  new Document('DefaultDocument-2', 'https://sec.net/documents/'),
+];

inc/tokenData.ts

+import {
+  AbiCoder,
+  BigNumberish,
+  BytesLike,
+  hexlify,
+  toBeHex,
+  keccak256,
+  toUtf8Bytes,
+  zeroPadValue,
+  id,
+} from 'ethers';
+
+export interface ERC20Details {
+  name: string;
+  symbol: string;
+  decimals: BigNumberish;
+  maxSupply: BigNumberish;
+}
+
+export interface EncodedPartition {
+  name: BytesLike;
+  data: BytesLike;
+}
+
+export class Document {
+  name: string;
+  nameHash: BytesLike;
+  uri: string;
+  documentHash: BytesLike;
+  timestamp: BigNumberish;
+
+  constructor(
+    name: string,
+    uri: string,
+    hash?: string,
+    timestamp?: BigNumberish,
+  ) {
+    this.name = name;
+    this.nameHash = keccak256(toUtf8Bytes(name));
+    this.uri = uri;
+    this.documentHash = hash ?? keccak256(this.nameHash);
+    this.timestamp = timestamp ?? 0n;
+  }
+}
+
+export class Variable {
+  name: string;
+  kind: string;
+  key: BytesLike;
+  value: BigNumberish;
+  encodedValue: BytesLike;
+
+  constructor(name: string, kind: string, value: BigNumberish) {
+    this.name = name;
+    this.kind = kind;
+    this.value = value;
+    this.key = toBytes32(name);
+    this.encodedValue = Variable.encodeValue(value);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static encodeValue(value: any): BytesLike {
+    return zeroPadValue(toBeHex(value.toString()), 32);
+  }
+
+  get() {
+    return {
+      key: this.key,
+      kind: this.kind,
+    };
+  }
+
+  encode(): BytesLike {
+    return AbiCoder.defaultAbiCoder().encode(
+      ['bytes32[]', 'bytes32[]'],
+      [[this.key], [this.encodedValue]],
+    );
+  }
+}
+
+export class Partition {
+  name: string;
+  key: BytesLike;
+  private variables: Map<BytesLike, Variable>;
+
+  constructor(name: string, variables: Array<Variable>) {
+    this.name = name;
+    this.key = toBytes32(name);
+    this.variables = new Map<BytesLike, Variable>();
+    variables.forEach(this.addVariable.bind(this));
+  }
+
+  getVariableValue(name: string): BigNumberish {
+    const variable = this.getVariable(name);
+    return variable.value;
+  }
+
+  getVariable(name: string): Variable {
+    const key = toBytes32(name);
+
+    if (!this.variables.has(key)) {
+      throw Error('invalid variable');
+    }
+
+    return this.variables.get(key);
+  }
+
+  getVariables(): Array<Variable> {
+    const variables = Array<Variable>();
+    this.variables.forEach(variable => {
+      variables.push(variable);
+    });
+    return variables;
+  }
+
+  addVariable(variable: Variable) {
+    this.variables.set(variable.key, variable);
+  }
+
+  setVariable(variable: Variable) {
+    if (this.variables.has(variable.key)) {
+      throw Error('variable already exist');
+    }
+
+    this.variables.set(variable.key, variable);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setVariableValue(name: string, value: any) {
+    const variable = this.getVariable(name);
+    variable.value = value;
+  }
+
+  encode(): BytesLike {
+    return AbiCoder.defaultAbiCoder().encode(
+      ['bytes32[]', 'bytes32[]'],
+      [this.getKeys(), this.getEncodedValues()],
+    );
+  }
+
+  toPartitionStruct() {
+    return {
+      name: this.key,
+      data: this.encode(),
+    };
+  }
+
+  private getEncodedValues(): Array<BytesLike> {
+    const values = Array<BytesLike>();
+    this.variables.forEach(variable => {
+      values.push(variable.encodedValue);
+    });
+    return values;
+  }
+
+  private getKeys(): Array<BytesLike> {
+    const keys = Array<BytesLike>();
+    this.variables.forEach((variable, key) => {
+      keys.push(key);
+    });
+    return keys;
+  }
+}
+
+/**
+ * Converts string to solidity byte32 representation
+ */
+export function toBytes32(data: string): BytesLike {
+  return hexlify(zeroPadValue(toUtf8Bytes(data), 32));
+}
+
+/**
+ * @returns random(not that random though) keccak256 hash
+ */
+export function randomID() {
+  const idx = Math.floor(Math.random() * 1_000_000);
+  return id(`random:${idx}`);
+}

inc/util.ts

+
+import {JsonRpcProvider} from 'ethers'
+import { readFileSync, writeFileSync } from 'fs';
+
+let providerUtil: JsonRpcProvider = null;
+
+function getElapsed(time: number,lens: number = 1000): number {
+    let elapsed = Date.now() - time;
+    return elapsed / lens;
+    //return Math.floor(elapsed/lens);
+}
+async function sleep(ms: number, message: string = 'wait..... ') {
+    //console.log(message);
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+}
+
+function setProvider(provider: JsonRpcProvider) {
+    providerUtil = provider;
+}
+
+async function checkReceipt(txids: any[], label: string = ''): Promise<boolean> {
+
+    const now = Date.now();
+    let counter = 0;
+    if(label != '') 
+        console.log(`wait... ${label}`);
+
+    let finCounter = 0;
+    while(true) {
+        
+        
+        for(let i = 0; i < txids.length; i++) {
+            let txid = txids[i].txid;
+            if(txids[i].finished) {
+                continue;
+            }
+            const receipt = await providerUtil.send('eth_getTransactionReceipt',[txid]);
+            if(receipt != null) {
+                txids[i].finished = true;
+                ++finCounter;
+                if(receipt.status = 1) {
+                    // if(label != '') {
+                    //     console.log(`${label} finished`);
+                    // }
+                    txids[i].status = true;
+                } else {
+                    txids[i].status = false;
+                }
+                //console.log(receipt);
+            }
+            sleep(5)
+        }
+
+        //console.log(`finsounter = ${finCounter}`);
+        if(finCounter == txids.length) {
+            // console.log(`finCounter = ${finCounter}`);
+            const elapsed = getElapsed(now,1000);
+            console.log(`receipt check elapsed = ${elapsed}`);
+            return true
+        }
+        counter++;
+        if(counter > 300) {
+            console.log(`Receipt check timed out ${finCounter}`);
+            return false;
+        }
+        await sleep(50);
+    }
+    return false;
+}
+
+async function checkReceipt2(txids: Map<string,boolean>,startEndTx: string[], label: string = ''): Promise<Map<string,any>> {
+
+    const now = Date.now();
+    let counter = 0;
+    if(label != '') {
+        console.log(`${label}`);
+    } else {
+        console.log(`wait for txs is finished... `);
+    }
+        
+
+    let returnMap = new Map<string,string>();
+
+    const loop = 300;
+    let finCounter = 0;
+    let receipts = [];
+    while(true) {
+        receipts = [];
+        //console.log(`size of sended tx... ${txids.size}`);
+        if(txids.size == 0) {
+            console.log('all tx finalized');
+            return returnMap;
+        }
+            
+
+        txids.forEach( (value: boolean, key: string) => {
+            if(!value) {
+                // console.log(key);
+                const receipt = providerUtil.send('eth_getTransactionReceipt',[key]);
+                receipts.push(receipt);
+            }
+        });
+
+        let recs = await Promise.all(receipts);
+        recs.forEach( res => {
+            if(res != null) {
+                //console.log(res.transactionHash);
+                startEndTx.forEach(txid => {
+                    if(res.transactionHash == txid) {
+                        returnMap.set(txid,res.blockHash);
+                    }
+                })
+                txids.delete(res.transactionHash);
+            }
+        })
+        counter++;
+        if(counter > loop) {
+            console.log(`Receipt check timed out ${finCounter}`);
+            return returnMap;
+        }
+
+        await sleep(50);
+    }
+    return returnMap;
+}
+
+async function getBlockInfo(blockHash: string, verbose: boolean = true): Promise<any> {
+    const info = await providerUtil.send('eth_getBlockByHash',[blockHash,verbose]);
+    return info;
+}
+
+async function getNonce(addr: string): Promise<number> {
+    const nonce = await providerUtil.getTransactionCount(addr);
+    return nonce;
+}
+
+const DEPLOYMENTS_JSON_FILE = 'deployments.json';
+export function saveDeploymentAddresses(
+    name: string,
+    deployments: any,
+  ) {
+const filename = name + '_' + DEPLOYMENTS_JSON_FILE;
+try {
+    writeFileSync(filename, JSON.stringify(deployments, null, 2), 'utf-8');
+} catch (_) {
+    console.log(`❕ no deployments file found with name ${filename}`);
+}
+}
+
+export function getDeploymentAddresses(name:string): any {
+const filename = name + '_' + DEPLOYMENTS_JSON_FILE;
+try {
+    return JSON.parse(readFileSync(filename, 'utf-8'));
+} catch (_) {
+    console.log(`❕ no deployments file found with name ${filename}`);
+    return {};
+}
+}
+
+export {checkReceipt,checkReceipt2, sleep, getElapsed, setProvider,getBlockInfo,getNonce }

inc/utils.sh

+#!/bin/bash
+
+# $1 = msg , $2 = count
+# ex) wait "Wait 5" 5
+function wait() {
+
+    msg=$1
+    count=0
+    total=$2
+    pstr="[=======================================================================]"
+
+    echo $msg
+
+    while [ $count -lt $total ]; do
+    sleep 1 # this is work
+    count=$(( $count + 1 ))
+    pd=$(( $count * 73 / $total ))
+    printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
+    done
+
+    echo ''
+}

package.json

+{
+  "name": "tta-cert",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/node": "^22.9.0",
+    "dotenv": "^16.4.5",
+    "ethers": "^6.13.4",
+    "hardhat-ethers": "^1.0.1",
+    "typescript": "^5.6.3"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-ethers": "^3.0.8",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.12",
+    "@nomicfoundation/hardhat-verify": "^2.0.12",
+    "@openzeppelin/hardhat-upgrades": "^3.5.0",
+    "@typechain/ethers-v6": "^0.5.1",
+    "@typechain/hardhat": "^9.1.0",
+    "hardhat": "^2.22.16",
+    "hardhat-contract-sizer": "^2.10.0",
+    "hardhat-deploy": "^0.14.0",
+    "hardhat-gas-reporter": "^2.2.1",
+    "hardhat-upgrades": "^0.0.0",
+    "solidity-coverage": "^0.8.13",
+    "ts-node": "^10.9.2",
+    "typechain": "^8.3.2"
+  }
+}

prepare/prepare-data.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash
+} from 'ethers'
+import {ethers} from 'hardhat';
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import {checkReceipt, setProvider,saveDeploymentAddresses} from '../inc/util'
+
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+
+async function prepareToken(name: string, symbol: string,decimal: number, total: number, 
+    contractOwner: Wallet | HardhatEthersSigner, 
+    issuer: Wallet | HardhatEthersSigner, 
+    holder1: string, holder2: string) 
+    {
+    const deployed = require('../security_token_deployments.json');
+    const tokenService = new TokenIssuer(contractOwner as Wallet,deployed.tokenBeacon,deployed.rulesBeacon,contractOwner.address);
+
+
+    const digit = 10 ** decimal
+    // let txid = await deployToken(name,symbol,6,amount * digit);
+
+
+    const controllers = ['0x9A563196bffCF278bFc16B89D1C19081E05A7eAE', '0x4Ebbec759d8a5cCd06aea5222362046fF620f1D5'];
+    const operators = ['0xFE3B557E8Fb62b89F4916B721be55cEb828dBd73'];
+    const lockers = ['0x9A563196bffCF278bFc16B89D1C19081E05A7eAE', '0x4Ebbec759d8a5cCd06aea5222362046fF620f1D5'];
+    
+    const proxy = await tokenService.deploy(name,symbol,decimal,total * digit,issuer.address,operators,lockers,controllers);
+
+    console.log(`new token deployed at ${proxy}`);
+    const token = new SecurityToken__factory(contractOwner).attach(proxy) as SecurityToken;
+    //token.connect(contractOwner);
+    
+    const sym = await token.symbol();
+    console.log(await token.name());
+    console.log(sym);
+    console.log(await token.maxSupply());
+
+    let r;
+    // r = await token.KYCtokenHolders([holder1]);
+    // await token.KYCtokenHolders([holder2]);
+    
+    const tokenForIssuer = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+    await tokenForIssuer.connect(issuer);
+    r = await tokenForIssuer.KYCtokenHolders([holder1]);
+    await tokenForIssuer.KYCtokenHolders([holder2]);
+
+    let txids = [];
+    txids.push({txid: r.hash});
+    await checkReceipt(txids, 'wait for tokenholder kyced');
+    
+    const b  = await tokenForIssuer.isTokenHolderKYC(holder1);
+    if(!b) {
+        console.log('holder kyc error');
+        return;
+    }
+
+    await tokenForIssuer.issue(holder1,50_000n,ZeroHash);
+    r = await tokenForIssuer.issue(holder2,50_000n,ZeroHash);
+
+    txids = [];
+    txids.push({txid: r.hash});
+    await checkReceipt(txids, 'wait for token issued');
+
+    let balance = await tokenForIssuer.balanceOf(holder1);
+    console.log(`holder1's balance = ${balance}`);
+
+    balance = await tokenForIssuer.balanceOf(holder2);
+    console.log(`holder2's balance = ${balance}`);
+    console.log('TestData created!');
+
+    saveDeploymentAddresses(symbol,{address: proxy})
+}
+
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+
+async function main() {
+
+    const admin = await ethers.provider.getSigner(0);
+    const issuer = await ethers.provider.getSigner(1);
+    const holder1 = await ethers.provider.getSigner(2);
+    const holder2 = await ethers.provider.getSigner(3);
+
+
+    // name: string, symbol: string,decimal: number, total: number
+    await prepareToken(
+        '테스트토큰','test001',6,1000000,
+        admin, issuer, holder1.address, holder2.address);
+}
+
+main();
+
+

security_token_deployments.json

+{
+  "tokenBeacon": "0x2B8fDBe61a2736767dc9bBD20654CA972E75279f",
+  "rulesBeacon": "0x7427f873bBB58A0448A9E6d6e19662c95db1aF35",
+
+  "tokenBeacon_l": "0xAa588d3737B611baFD7bD713445b314BD453a5C8",
+  "rulesBeacon_l": "0x30753E4A8aad7F8597332E813735Def5dD395028"
+}

test001_deployments.json

+{
+  "address": "0xAee7F3641abe7B3fe364325Df0482Af04fc638b2"
+}

token_swap_deployments.json

+{
+  "proxy": "0x9FBDa871d559710256a2502A2517b794B482Db40",
+  "swap": "0x8f0483125FCb9aaAEFA9209D8E9d7b9C8B9Fb90F"
+}

tsconfig.json

+{
+	"compilerOptions": {
+		"target": "es2020",
+		"module": "commonjs",
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"strict": false,
+		"skipLibCheck": true,
+		"resolveJsonModule": true,
+		"allowJs": true,
+        "useUnknownInCatchVariables": false
+	}
+}

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

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

typechain/@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 };

typechain/@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
+    >;
+  };
+}

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

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

typechain/@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 };

typechain/@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: {};
+}

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

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

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

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

typechain/@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: {};
+}

typechain/@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: {};
+}

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

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

typechain/@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";

typechain/@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: {};
+}

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

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

typechain/@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 };

typechain/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>;
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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"
+      | "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: "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: "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">;
+
+  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: "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
+    >;
+  };
+}

typechain/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"
+      | "balanceOfByPartition"
+      | "isOperatorFor"
+      | "isTokenHolderKYC"
+      | "issueByPartition"
+      | "operatorRedeemByPartition"
+      | "operatorTransferByPartition"
+      | "partitionsOf"
+      | "revokeOperator"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "AuthorizedOperator"
+      | "IssuedByPartition"
+      | "RedeemedByPartition"
+      | "RevokedOperator"
+      | "TransferByPartition"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "authorizeOperator",
+    values: [AddressLike, AddressLike[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "balanceOfByPartition",
+    values: [BytesLike, AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "isOperatorFor",
+    values: [AddressLike, 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: "balanceOfByPartition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "isOperatorFor",
+    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"
+  >;
+
+  balanceOfByPartition: TypedContractMethod<
+    [_partition: BytesLike, _tokenHolder: AddressLike],
+    [bigint],
+    "view"
+  >;
+
+  isOperatorFor: TypedContractMethod<
+    [_operator: AddressLike, _tokenHolder: AddressLike],
+    [boolean],
+    "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: "balanceOfByPartition"
+  ): TypedContractMethod<
+    [_partition: BytesLike, _tokenHolder: AddressLike],
+    [bigint],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "isOperatorFor"
+  ): TypedContractMethod<
+    [_operator: AddressLike, _tokenHolder: AddressLike],
+    [boolean],
+    "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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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"
+      | "maxSupply"
+      | "name"
+      | "symbol"
+      | "totalSupply"
+  ): FunctionFragment;
+
+  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "balanceOf",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "decimals", 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: "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">;
+
+  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: "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
+    >;
+  };
+}

typechain/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";

typechain/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: {};
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/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 { Locker } from "./Locker";
+export type { Operator } from "./Operator";

typechain/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: {};
+}

typechain/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
+    >;
+  };
+}

typechain/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 interface ILockableInterface extends Interface {
+  getFunction(nameOrSignature: "createLock" | "removeLock"): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "createLock",
+    values: [BytesLike, AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLock",
+    values: [BytesLike, AddressLike, BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "createLock", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "removeLock", 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, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  removeLock: TypedContractMethod<
+    [partition: BytesLike, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "createLock"
+  ): TypedContractMethod<
+    [partition: BytesLike, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "removeLock"
+  ): TypedContractMethod<
+    [partition: BytesLike, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  filters: {};
+}

typechain/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 interface LockableInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "LOCKER_ROLE"
+      | "createLock"
+      | "getRoleMembers"
+      | "getRoleMembersLength"
+      | "hasLock"
+      | "hasRole"
+      | "isLocker"
+      | "lockedAmount"
+      | "lockers"
+      | "removeLock"
+      | "totalLockedAmount"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "Initialized"
+      | "LockCreated"
+      | "LockReleased"
+      | "RoleGranted"
+      | "RoleRevoked"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "LOCKER_ROLE",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "createLock",
+    values: [BytesLike, AddressLike, BigNumberish]
+  ): 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]
+  ): string;
+  encodeFunctionData(functionFragment: "lockers", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "removeLock",
+    values: [BytesLike, AddressLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalLockedAmount",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "LOCKER_ROLE",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "createLock", 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;
+}
+
+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,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [account: string, partition: string, value: bigint];
+  export interface OutputObject {
+    account: string;
+    partition: 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,
+    value: BigNumberish
+  ];
+  export type OutputTuple = [account: string, partition: string, value: bigint];
+  export interface OutputObject {
+    account: string;
+    partition: 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, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  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],
+    [bigint],
+    "view"
+  >;
+
+  lockers: TypedContractMethod<[], [string[]], "view">;
+
+  removeLock: TypedContractMethod<
+    [partition: BytesLike, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+
+  totalLockedAmount: TypedContractMethod<
+    [account: AddressLike],
+    [bigint],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "LOCKER_ROLE"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "createLock"
+  ): TypedContractMethod<
+    [partition: BytesLike, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+  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],
+    [bigint],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "lockers"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "removeLock"
+  ): TypedContractMethod<
+    [partition: BytesLike, holder: AddressLike, value: BigNumberish],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "totalLockedAmount"
+  ): TypedContractMethod<[account: AddressLike], [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,uint256)": TypedContractEvent<
+      LockCreatedEvent.InputTuple,
+      LockCreatedEvent.OutputTuple,
+      LockCreatedEvent.OutputObject
+    >;
+    LockCreated: TypedContractEvent<
+      LockCreatedEvent.InputTuple,
+      LockCreatedEvent.OutputTuple,
+      LockCreatedEvent.OutputObject
+    >;
+
+    "LockReleased(address,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
+    >;
+  };
+}

typechain/contracts/extensions/index.ts

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

typechain/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 access from "./access";
+export type { access };
+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 { IProvideSelector } from "./IProvideSelector";
+export type { SecurityToken } from "./SecurityToken";
+export type { TokenSwap } from "./TokenSwap";

typechain/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[],
+      data: 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[],
+      data: 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
+    >;
+  };
+}

typechain/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: {};
+}

typechain/contracts/mock/extensions/index.ts

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

typechain/contracts/mock/index.ts

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

typechain/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
+    >;
+  };
+}

typechain/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
+    >;
+  };
+}

typechain/contracts/partitions/index.ts

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

typechain/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: {};
+}

typechain/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[],
+      data: 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[],
+      data: 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
+    >;
+  };
+}

typechain/contracts/rules/index.ts

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

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

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

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

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

typechain/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;
+  }
+}

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

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

typechain/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";

typechain/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;
+  }
+}