Merge branch 'master' of https://git.jongheeda.synology.me/jongheeda/TTA-Cert

.env

 # CHAINID=1337
 
 #OCI
-RPCURL=http://193.123.252.127:80
+#RPCURL=http://193.123.252.127:80
+#WSURL=ws://193.123.252.127/ws
+
+RPCURL=http://132.145.89.161:8545
 CHAINID=1337
-GATE_WAY=https://api.stopulse.co.kr/main/v1/
+GATE_WAY=http://api.stopulse.co.kr/main/v1/
+GATE_WAY_RAW=http://api.stopulse.co.kr/
 AUTHTOKEN=580c6006687220df84f83d7c345c00ad9829de0694bd00c09e211d8c810b7510
+
+
+
+#dev
+# RPCURL=http://193.123.252.127:80
+# CHAINID=1337
+# GATE_WAY=http://172.25.1.108/main/v1/
+# GATE_WAY_RAW=http://172.25.1.108/
+# AUTHTOKEN=18851850e4237cc34ea0a7a1de7cb5af362ee854363b60983ed4c18d9b12cb27
+
+
+

BCG_TEST_deployments copy.json

+{
+  "address": "0x42707a63160580896582e65703e0985d920f9ca6"
+}

BCG_TEST_deployments.json

 {
-  "address": "0x42707a63160580896582e65703e0985d920f9ca6"
+  "address": "0xA3a3112b6C00225f1Aa331c2EbCD691d1De3f2bd"
 }

KSD01/listen.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+// 문자열을 bytes32로 변환하는 함수
+const toBytes32 = (inputString: string): string => {
+    return web3.utils.asciiToHex(inputString).padEnd(66, '0'); // 32 bytes로 패딩 추가
+};
+  
+  // bytes32를 문자열로 변환하는 함수
+const bytes32ToString = (bytes32: string): string => {
+    return web3.utils.hexToAscii(bytes32).replace(/\0/g, ''); // null 문자 제거
+};
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+async function issueKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+) {    
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    // const decimals = await token.decimals();
+    // console.log(decimals);
+    // const symbol = await token.symbol();
+    // console.log(symbol);
+    // const is = await token.retrieveIsinKSD(toBytes32(isin));
+    // console.log( bytes32ToString(is));
+
+    let r = await token.issueKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+async function listenIssuable(tokenAddress: string, operator: Wallet, isin: string) {
+
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+    token.on(token.filters.TokenIssuableKSD2,(isin,totalIssueQty,KSDAccounts,amounts,slipSeqKSD, event) => {
+
+        console.log(`TokenIssuableKSD2 event received at ${tokenAddress} , ${isin}`);    
+        console.log(`${isin} , ${totalIssueQty} , ${KSDAccounts} , ${amounts} , ${slipSeqKSD}`);
+        console.log(event);
+        
+        // const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+        // const ksdAccountCustomer = '000002000002';
+        // issueKSD(tokenAddress,operator,isin,accountCustomer,ksdAccountCustomer,Number(amounts),toBytes32(slipSeqKSD)).catch((error) => {
+        //     console.log(error);
+        // });
+
+    });
+
+    token.on(token.filters.TokenIssuableKSD,(isin,slipSeqKSD, event) => {
+        console.log(`TokenIssuableKSD event received at ${tokenAddress} , ${isin}`);
+        console.log(`${isin} - ${slipSeqKSD}`);
+        console.log(event);
+    });
+
+    // const filter = token.filters.TokenIssuableKSD(null,null);
+    // token.on(filter,(isin,slipSeqKSD, event) => {
+    //     console.log(event);
+    // });
+
+    // const abi = ['event TokenIssuableKSD(bytes32 isin, bytes32 slipSeqKSD)'];
+    // //const singer: JsonRpcSigner = await provider.getSigner();
+    // const contract = new Contract(
+    //   tokenAddress,
+    //   abi,
+    //   operator
+    // );
+    
+    // //contract.on('TokenIssuableKSD', (isin,slipSeqKSD, event) => {
+    // contract.on('TokenIssuableKSD', (data) => {
+    //   console.log(data);
+    //     // TokenIssuableKSD 에서 저장한 정보를 찾아서
+    //   //issueKSD()
+    //   });
+      
+    console.log(`Listening for TokenIssuableKSD events... at ${tokenAddress} , ${isin}`);
+    setInterval(() => {}, 1000);
+  }
+
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED
+
+const accountSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountSelf = '000002000001';
+const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountCustomer = '000002000002';
+
+async function main() {
+
+    //,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+
+    // KR5STO000202
+    let symbol = 'KR5STO000166';
+    let qty = 1000000000;
+    let rsnCode = '203';
+    let tokenAddress = '0x920c017843904A735458AA9d30779bE5FCfcF411';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000177'
+    tokenAddress = '0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000188'
+    tokenAddress = '0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000199'
+    tokenAddress = '0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000202'
+    tokenAddress = '0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+    
+
+
+}
+
+main();
+
+

KSD01/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+// 문자열을 bytes32로 변환하는 함수
+const toBytes32 = (inputString: string): string => {
+    return web3.utils.asciiToHex(inputString).padEnd(66, '0'); // 32 bytes로 패딩 추가
+};
+  
+  // bytes32를 문자열로 변환하는 함수
+const bytes32ToString = (bytes32: string): string => {
+    return web3.utils.hexToAscii(bytes32).replace(/\0/g, ''); // null 문자 제거
+};
+
+
+// function toBytes32(data: string): BytesLike {
+//     return hexlify(zeroPadValue(toUtf8Bytes(data), 32));
+// }
+  
+// /**
+//  * Converts solidity byte32 to utf8 string
+//  */
+// function bytes32ToString(data: BytesLike): string {
+// return toUtf8String(stripZerosLeft(data));
+// }
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+async function issueKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+) {    
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    const decimals = await token.decimals();
+    console.log(decimals);
+    const symbol = await token.symbol();
+    console.log(symbol);
+
+    const is = await token.retrieveIsinKSD(toBytes32(isin));
+    console.log( bytes32ToString(is));
+
+    let r = await token.issueKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+
+async function disposalLimitSetupKSD(address: string, operator: Wallet
+    ,isin: string, 
+    account: string, KSDAccount: string, rsnCode: string, qty: number
+)  {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.disposalLimitSetupKSD(toBytes32(isin),account,KSDAccount,toBytes32(rsnCode),qty);
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+
+}
+
+//function erasureKSD(bytes32 isin, address account, bytes32 KSDAccount, uint256 qty, bytes32 rsnCode, bytes32 slipSeqKSD) external;
+async function erasureKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, rsnCode: string, slipSeqKSD: string
+) {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.erasureKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(rsnCode),toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED
+
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x9D084404B8558604a1e69B9782A6f421870bd907 - 폐기된 종목
+
+
+const accountSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountSelf = '000002000001';
+
+const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountCustomer = '000002000002';
+
+const accountHanwha = '0xf48de4a0c2939e62891f3c6aca68982975477e45';
+const ksdAccountHanwha = '000021000002';
+
+const accountMeritz = '0x0886328869e4e1f401e1052a5f4aae8b45f42610';
+const ksdAccountMeritz = '000010000002';
+
+
+
+async function main() {
+
+    //,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+    // 종목20
+    let tokenAddress = '0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED';
+    let slipSeqKSD = '001202503100000000008';
+    const Symbol1 = 'KR5STO000202';
+    let qty = 300000;
+    // await issueKSD(tokenAddress,admin,
+    //     Symbol1,
+    //     accountMeritz,
+    //     ksdAccountMeritz,
+    //     qty,
+    //     slipSeqKSD
+    // );
+
+    await balanceOf(tokenAddress,admin,Symbol1,accountCustomer);
+
+
+
+    // qty = 100000;
+    // let rsnCode = '203';
+    // ,isin: string, account: string, KSDAccount: string, rsnCode: string, qty: number
+    // await disposalLimitSetupKSD(tokenAddress,admin,
+    //     Symbol1,
+    //     accountCustomer,
+    //     ksdAccountCustomer,
+    //     rsnCode,
+    //     qty
+    // );
+
+    // rsnCode = '203';
+    // ,isin: string, account: string, KSDAccount: string, qty: number, rsnCode: string, slipSeqKSD: string
+    // await erasureKSD(tokenAddress,admin,
+    //     Symbol1,
+    //     accountCustomer,
+    //     ksdAccountCustomer,
+    //     qty,
+    //     rsnCode,
+    //     slipSeqKSD
+    // );
+
+
+}
+
+main();
+
+

KSD01/start2.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+// 문자열을 bytes32로 변환하는 함수
+const toBytes32 = (inputString: string): string => {
+    return web3.utils.asciiToHex(inputString).padEnd(66, '0'); // 32 bytes로 패딩 추가
+};
+  
+  // bytes32를 문자열로 변환하는 함수
+const bytes32ToString = (bytes32: string): string => {
+    return web3.utils.hexToAscii(bytes32).replace(/\0/g, ''); // null 문자 제거
+};
+
+import tokenContract from '../SecurityToken.json'
+
+// function toBytes32(data: string): BytesLike {
+//     return hexlify(zeroPadValue(toUtf8Bytes(data), 32));
+// }
+// /**
+//  * Converts solidity byte32 to utf8 string
+//  */
+// function bytes32ToString(data: BytesLike): string {
+// return toUtf8String(stripZerosLeft(data));
+// }
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+
+    const token = new ethers.Contract(
+        tokenAddress,
+        tokenContract.abi,
+        operator
+    );
+
+    // const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    // await token.connect(operator);
+
+    const symbol = await token.symbol();
+    console.log(symbol);
+
+    const i = await token.retrieveIsin();
+    console.log( bytes32ToString(i));
+
+    console.log(toBytes32(isin));
+    // const is = await token.retrieveIsinKSD(toBytes32('KR5STO000177'));
+    // console.log( bytes32ToString(is));
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+async function issueKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+) {    
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    const decimals = await token.decimals();
+    console.log(decimals);
+    const symbol = await token.symbol();
+    console.log(symbol);
+
+    const is = await token.retrieveIsinKSD(toBytes32(isin));
+    console.log( bytes32ToString(is));
+
+    let r = await token.issueKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+
+async function disposalLimitSetupKSD(address: string, operator: Wallet
+    ,isin: string, 
+    account: string, KSDAccount: string, rsnCode: string, qty: number
+)  {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.disposalLimitSetupKSD(toBytes32(isin),account,KSDAccount,toBytes32(rsnCode),qty);
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+
+}
+
+//function erasureKSD(bytes32 isin, address account, bytes32 KSDAccount, uint256 qty, bytes32 rsnCode, bytes32 slipSeqKSD) external;
+async function erasureKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, rsnCode: string, slipSeqKSD: string
+) {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.erasureKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(rsnCode),toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED
+// KR5STO000200 (토큰증권 테스트 종목20) -> 0x9D084404B8558604a1e69B9782A6f421870bd907 - 폐기된 종목
+
+
+
+const accountSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountSelf = '000002000001';
+const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountCustomer = '000002000002';
+
+async function main() {
+
+    
+    console.log(bytes32ToString('0x4b523553544f3030303136360000000000000000000000000000000000000000'));
+
+    console.log(bytes32ToString('0x3030303030323030303030320000000000000000000000000000000000000000'));
+    console.log(bytes32ToString('0x3030303031303030303030320000000000000000000000000000000000000000'));
+    console.log(bytes32ToString('0x3030303032313030303030320000000000000000000000000000000000000000'));
+    
+
+    console.log(bytes32ToString('0x3030313230323530333130303030303030303030380000000000000000000000'));
+
+
+
+}
+
+main();
+
+

KSD02/listen.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+import {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}`);
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+// 문자열을 bytes32로 변환하는 함수
+const toBytes32 = (inputString: string): string => {
+    return web3.utils.asciiToHex(inputString).padEnd(66, '0'); // 32 bytes로 패딩 추가
+};
+  
+  // bytes32를 문자열로 변환하는 함수
+const bytes32ToString = (bytes32: string): string => {
+    return web3.utils.hexToAscii(bytes32).replace(/\0/g, ''); // null 문자 제거
+};
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+
+
+async function listenIssuable(tokenAddress: string, operator: Wallet, isin: string) {
+
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+    token.on(token.filters.TokenIssuableKSD2,(isin,totalIssueQty,KSDAccounts,amounts,slipSeqKSD, event) => {
+
+        console.log(`TokenIssuableKSD2 event received at ${tokenAddress} , ${isin}`);    
+        console.log(`${isin} , ${totalIssueQty} , ${KSDAccounts} , ${amounts} , ${slipSeqKSD}`);
+        console.log(event);
+    });
+
+    token.on(token.filters.TokenIssuableKSD,(isin,slipSeqKSD, event) => {
+        console.log(`TokenIssuableKSD event received at ${tokenAddress} , ${isin}`);
+        console.log(`${isin} - ${slipSeqKSD}`);
+        console.log(event);
+    });
+
+    // const filter = token.filters.TokenIssuableKSD(null,null);
+    // token.on(filter,(isin,slipSeqKSD, event) => {
+    //     console.log(event);
+    // });
+
+    // const abi = ['event TokenIssuableKSD(bytes32 isin, bytes32 slipSeqKSD)'];
+    // //const singer: JsonRpcSigner = await provider.getSigner();
+    // const contract = new Contract(
+    //   tokenAddress,
+    //   abi,
+    //   operator
+    // );
+    
+    // //contract.on('TokenIssuableKSD', (isin,slipSeqKSD, event) => {
+    // contract.on('TokenIssuableKSD', (data) => {
+    //   console.log(data);
+    //     // TokenIssuableKSD 에서 저장한 정보를 찾아서
+    //   //issueKSD()
+    //   });
+      
+    console.log(`Listening for TokenIssuableKSD events... at ${tokenAddress} , ${isin}`);
+    setInterval(() => {}, 1000);
+  }
+
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED
+
+const accountSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountSelf = '000002000001';
+const accountCustomer = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountCustomer = '000002000002';
+
+async function main() {
+
+    //,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+
+    // KR5STO000202
+    let symbol = 'KR5STO000166';
+    let qty = 1000000000;
+    let rsnCode = '203';
+    let tokenAddress = '0x920c017843904A735458AA9d30779bE5FCfcF411';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000177'
+    tokenAddress = '0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000188'
+    tokenAddress = '0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000199'
+    tokenAddress = '0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+
+    symbol = 'KR5STO000202'
+    tokenAddress = '0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED';
+    listenIssuable(tokenAddress,admin, symbol).catch((error) => {
+        console.log(error);
+    });
+    
+
+
+}
+
+main();
+
+

KSD02/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+// 문자열을 bytes32로 변환하는 함수
+const toBytes32 = (inputString: string): string => {
+    return web3.utils.asciiToHex(inputString).padEnd(66, '0'); // 32 bytes로 패딩 추가
+};
+  
+// bytes32를 문자열로 변환하는 함수
+const bytes32ToString = (bytes32: string): string => {
+    return web3.utils.hexToAscii(bytes32).replace(/\0/g, ''); // null 문자 제거
+};
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+/// @notice 계좌대체 표준 함수
+/// @param isin 종목 isin 코드
+/// @param accountFrom 송신 지갑주소
+/// @param KSDAccountFrom 송신 642계좌
+/// @param accountTo 수신 지갑주소
+/// @param KSDAccountTo 수신 642계좌
+/// @param qty 전송 수량
+/// @param rsnCode 사유코드
+//function transferKSD(bytes32 isin, address accountFrom, bytes32 KSDAccountFrom, address accountTo, bytes32 KSDAccountTo, uint256 qty, bytes32 rsnCode) external;
+
+async function transferKSD(address: string, operator: Wallet
+    ,isin: string, accountFrom: string, KSDAccountFrom: string, accountTo: string, KSDAccountTo: string, qty: number, rsnCode: string
+) { 
+    console.log(`transferKSD(${isin},${accountFrom},${KSDAccountFrom},${accountTo},${KSDAccountTo},${qty},${rsnCode})`);
+
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.transferKSD(
+        toBytes32(isin),
+        accountFrom,toBytes32(KSDAccountFrom),
+        accountTo,toBytes32(KSDAccountTo),
+        qty,
+        toBytes32(rsnCode),
+        {gasLimit: 2100000});
+
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+
+}
+
+async function issueKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, slipSeqKSD: string
+) {    
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    const decimals = await token.decimals();
+    console.log(decimals);
+    const symbol = await token.symbol();
+    console.log(symbol);
+
+    const is = await token.retrieveIsinKSD(toBytes32(isin));
+    console.log( bytes32ToString(is));
+
+    let r = await token.issueKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED
+
+// 신한 자기분계좌
+const accountShinhanSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountShinhanSelf = '000002000001';
+// 신한 고객분계좌
+const accountShinhan = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountShinhan = '000002000002';
+
+// 한화 자기분
+const accountHanwhaSelf = '0xc575ebd70f293a2d1a74c3cb4058e439f1996922';
+const ksdAccountHanwhaSelf = '000021000001';
+// 한화 고객분계좌
+const accountHanwha = '0xf48de4a0c2939e62891f3c6aca68982975477e45';
+const ksdAccountHanwha = '000021000002';
+
+
+// 메리츠 고객분계좌
+const accountMeritz = '0x0886328869e4e1f401e1052a5f4aae8b45f42610';
+const ksdAccountMeritz = '000010000002';
+
+
+async function main() {
+
+    
+    // 종목17
+    let tokenAddress = '0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F';
+    let symbol = 'KR5STO000177';
+    let qty = 500000;
+    // 신한(고객) -> 한화(자기)
+    // await transferKSD(tokenAddress,admin,
+    //     symbol,
+    //     accountShinhan,
+    //     ksdAccountShinhan,
+    //     accountHanwhaSelf,
+    //     ksdAccountHanwhaSelf,
+    //     qty,
+    //     '000'
+    // );
+    
+    // 종목18
+    tokenAddress = '0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf';
+    symbol = 'KR5STO000188';
+    qty = 250000;
+    // 신한(고객) -> 신한(자기)
+    // await transferKSD(tokenAddress,admin,
+    //     symbol,
+    //     accountShinhan,
+    //     ksdAccountShinhan,
+    //     accountShinhanSelf,
+    //     ksdAccountShinhanSelf,
+    //     qty,
+    //     '000'
+    // );
+
+
+    // 종목20
+    tokenAddress = '0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED';
+    symbol = 'KR5STO000202';
+
+    qty = 200000;
+    // 신한(고객) -> 메리츠(고객)
+    // await transferKSD(tokenAddress,admin,
+    //     symbol,
+    //     accountShinhan,
+    //     ksdAccountShinhan,
+    //     accountMeritz,
+    //     ksdAccountMeritz,
+    //     qty,
+    //     '000'
+    // );
+    
+    qty = 200000;
+    // 메리츠(고객) -> 한화(고객)
+    // await transferKSD(tokenAddress,admin,
+    //     symbol,
+    //     accountMeritz,
+    //     ksdAccountMeritz,
+    //     accountHanwha,
+    //     ksdAccountHanwha,
+    //     qty,
+    //     '000'
+    // );
+
+    qty = 200000;
+    // 한화(고객) -> 신한(고객)
+    // await transferKSD(tokenAddress,admin,
+    //     symbol,
+    //     accountHanwha,
+    //     ksdAccountHanwha,
+    //     accountShinhan,
+    //     ksdAccountShinhan,
+    //     qty,
+    //     '000'
+    // );
+
+    
+    await balanceOf(tokenAddress,admin,symbol,accountShinhan);
+}
+
+main();
+
+

KSD03/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id,
+    hexlify,
+    BytesLike,
+    toUtf8Bytes,
+    zeroPadValue,
+    stripZerosLeft
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain2'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+import { Operator } from '../typechain/contracts/access/Operator';
+import { stringify } from 'querystring';
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
+    getElapsed, sleep,getBlockInfo} from '../inc/util'
+dotevnv.config();
+if (!process.env.RPCURL) {
+    console.log(`No rpcur value specified...`)
+}
+console.log(`목적 서버 : ${process.env.RPCURL}`);
+
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+// 문자열을 bytes32로 변환하는 함수
+const toBytes32 = (inputString: string): string => {
+    return web3.utils.asciiToHex(inputString).padEnd(66, '0'); // 32 bytes로 패딩 추가
+};
+  
+// bytes32를 문자열로 변환하는 함수
+const bytes32ToString = (bytes32: string): string => {
+    return web3.utils.hexToAscii(bytes32).replace(/\0/g, ''); // null 문자 제거
+};
+
+async function balanceOf(tokenAddress: string, operator: Wallet,
+    isin: string, account: string) 
+{
+    const token = new SecurityToken__factory(operator).attach(tokenAddress) as SecurityToken;
+    await token.connect(operator);
+
+
+    const balance = await token.balanceOfKSD(toBytes32(isin),account);
+
+    console.log(balance);
+
+}
+
+async function erasureKSD(address: string, operator: Wallet
+    ,isin: string, account: string, KSDAccount: string, qty: number, rsnCode: string, slipSeqKSD: string
+) {
+    const token = new SecurityToken__factory(operator).attach(address) as SecurityToken;
+    await token.connect(operator);
+
+    let r = await token.erasureKSD(toBytes32(isin),account,toBytes32(KSDAccount),qty,toBytes32(rsnCode),toBytes32(slipSeqKSD),{gasLimit: 2100000});
+    const receipt1 = await r.wait();
+    console.log(receipt1.hash);
+}
+
+
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+// KR5STO000166 (토큰증권 테스트 종목16) -> 0x920c017843904A735458AA9d30779bE5FCfcF411
+// KR5STO000177 (토큰증권 테스트 종목17) -> 0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F
+// KR5STO000188 (토큰증권 테스트 종목18) -> 0x984f4DbAD8fC003138312293Fd431E5D8bAC1daf
+// KR5STO000199 (토큰증권 테스트 종목19) -> 0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247
+// KR5STO000202 (토큰증권 테스트 종목20) -> 0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED
+
+// 신한 자기분계좌
+const accountShinhanSelf = '0x8909ba8b4dd517de907ab83dc5226352a151f74f';
+const ksdAccountShinhanSelf = '000002000001';
+// 신한 고객분계좌
+const accountShinhan = '0x1C69DB7373505C1b69c9A2Dce0Be88EeE3c5f5e5';
+const ksdAccountShinhan = '000002000002';
+
+// 한화 자기분
+const accountHanwhaSelf = '0xc575ebd70f293a2d1a74c3cb4058e439f1996922';
+const ksdAccountHanwhaSelf = '000021000001';
+// 한화 고객분계좌
+const accountHanwha = '0xf48de4a0c2939e62891f3c6aca68982975477e45';
+const ksdAccountHanwha = '000021000002';
+
+
+// 메리츠 고객분계좌
+const accountMeritz = '0x0886328869e4e1f401e1052a5f4aae8b45f42610';
+const ksdAccountMeritz = '000010000002';
+
+
+async function main() {
+   
+
+    const slipSeqKSD = '003202503120000000006';
+    const rsnCode = '316';
+
+    // 종목17
+    let tokenAddress = '0x3e7757d67F2DBc9C2D9d69d74eCF0E498988da4F';
+    let symbol = 'KR5STO000177';
+    let qty = 500000;
+    let account = accountShinhan;
+    let ksdAccount = ksdAccountShinhan;
+    //await erasureKSD(tokenAddress,admin,symbol,account,ksdAccount,qty,rsnCode,slipSeqKSD);
+
+    
+    // 종목19
+    tokenAddress = '0xa36116158Cdfbcc57c3FEB9cc2A1cdfF8Cf5e247';
+    symbol = 'KR5STO000199';
+    
+    qty = 150000;
+    account = accountShinhan;
+    ksdAccount = ksdAccountShinhan;
+    //await erasureKSD(tokenAddress,admin,symbol,account,ksdAccount,qty,rsnCode,slipSeqKSD);
+
+    qty = 150000;
+    account = accountHanwha;
+    ksdAccount = ksdAccountHanwha;
+    //await erasureKSD(tokenAddress,admin,symbol,account,ksdAccount,qty,rsnCode,slipSeqKSD);
+
+    // 종목20
+    tokenAddress = '0x93302A7eeD96b27D47Ec692c6560cA5Fd5E9e7ED';
+    symbol = 'KR5STO000202';
+    
+    qty = 400000;
+    account = accountShinhan;
+    ksdAccount = ksdAccountShinhan;
+    //await erasureKSD(tokenAddress,admin,symbol,account,ksdAccount,qty,rsnCode,slipSeqKSD);
+
+    qty = 300000;
+    account = accountMeritz;
+    ksdAccount = ksdAccountMeritz;
+    //await erasureKSD(tokenAddress,admin,symbol,account,ksdAccount,qty,rsnCode,slipSeqKSD);
+
+    qty = 300000;
+    account = accountHanwha;
+    ksdAccount = ksdAccountHanwha;
+    //await erasureKSD(tokenAddress,admin,symbol,account,ksdAccount,qty,rsnCode,slipSeqKSD);
+    
+
+
+    await balanceOf(tokenAddress,admin,symbol,accountShinhan);
+}
+
+
+function printParam() {
+
+console.log('##################################################################################');
+console.log('disposalLimitSetupKSD');
+console.log('isin');
+console.log(bytes32ToString('0x4b523553544f3030303138380000000000000000000000000000000000000000'));
+console.log('account');
+console.log('0x8909ba8b4dd517de907ab83dc5226352a151f74f');
+console.log('KSDAccount');
+console.log(bytes32ToString('0x3030303030323030303030310000000000000000000000000000000000000000'));
+console.log('rsnCode');
+console.log(bytes32ToString('0x3331360000000000000000000000000000000000000000000000000000000000'));
+console.log('qty');
+console.log('250000');
+
+
+
+console.log('##################################################################################');
+console.log('tokenErasableKSD');
+console.log('isin');
+console.log(bytes32ToString('0x4b523553544f3030303138380000000000000000000000000000000000000000'));
+console.log('todalErasureQty');
+
+console.log('250000');
+console.log('KSDAccounts');
+console.log(`[${bytes32ToString('0x3030303030323030303030310000000000000000000000000000000000000000')}]`);
+
+console.log('slipSeqKSD');
+console.log(bytes32ToString('0x3030333230323530333131303030303030303030360000000000000000000000'));
+console.log('amounts');
+console.log(`[${250000}]`);
+
+
+
+console.log('##################################################################################');
+console.log('disposalLimitErasureKSD');
+console.log('isin');
+console.log(bytes32ToString('0x4b523553544f3030303138380000000000000000000000000000000000000000'));
+console.log('account');
+console.log('0x8909ba8b4dd517de907ab83dc5226352a151f74f');
+console.log('KSDAccount');
+console.log(bytes32ToString('0x3030303030323030303030310000000000000000000000000000000000000000'));
+console.log('rsnCode');
+console.log(bytes32ToString('0x3331360000000000000000000000000000000000000000000000000000000000'));
+console.log('qty');
+console.log('250000');
+console.log('slipSeqKSD');
+console.log(bytes32ToString('0x303033323032353033313130303030303030303036'));
+
+}
+
+//printParam();
+main();
+
+

POC/spf-init.ts

+// 
+
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, ethers ,Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    decodeBase64
+} from 'ethers'
+import { connect } from 'http2';
+
+const PF_TOKEN_ABI = [
+  "function mint(address to, uint256 amount) external",
+  "function transfer(address to, uint256 amount) external returns (bool)",
+  "function batchMint(address[] calldata recipients, uint256[] calldata amounts) external",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function totalSupply() external view returns (uint256)",
+  "function name() external view returns (string)",
+  "function symbol() external view returns (string)",
+  "function decimals() external view returns (uint8)",
+  "function hasRole(bytes32 role, address account) external view returns (bool)",
+  "event TokensMinted(address indexed to, uint256 amount, address indexed minter)",
+
+  "function recordInterestPayment(uint256 amount) external",
+];
+
+const SHS_ADDRESS="0x306f182eEdfe85d61aC2eA88acE58f565edf3DFe";
+const SHS_PRIVATE_KEY="0x3221ea02f27a2929f3a7ec75f5cac6f8207eb910a66f7e31d6391143dfbef5bf";
+const MASSET_ADDESS="0xDfc4dB2811a325DDd296C55D7A4055eD3bdB391D";
+const MASSET_PRIVATE_KEY="0x920a8a7f062b2f31da7bea211af1a5c0adb316e32301040c19d1d3748d6b7ab0";
+
+
+//TR_A
+// export const SPF_CONTRACT_ADDRESS =
+//   "0x4e4637E3199E8a11a6dDafF64F1DCc8c7C2Aab36"; // sPF 주소
+// export const SPF_CONTRACT_ADDRESS =
+//   "0x3B24bfdD5D52d4b25EE5812F35334A831ecA553d"; // sPF 주소 (이자함수포함)
+  
+
+//TR_B
+// export const SPF_CONTRACT_ADDRESS =
+//   "0xa1b2A55AEaEf5093fc9b04438Dc194C3B631f118"; // sPF 주소
+export const SPF_CONTRACT_ADDRESS =
+  "0xaB72Fe1511ac371E369DFf3B0f6Bba23198baFD2"; // sPF 주소 (이자함수포함)
+
+
+const PULSE_RPC_URL = "https://secuchain.testnet.stopulse.co.kr/";
+
+
+// export const SOL_ADDRESS = "0x8DFeB78ecEe391149b1c2739cEd0f6992D0a5663";
+// const PRIVATE_KEY =
+//   "0x47c496fe62e38aebcf4c5298cdae6889efed27b308fb473311d4a209e512f20e";
+
+const PULSE_PRIVATE_KEY =
+  "0xcd2336d7c471a0f2f1da77e91bcaf71e96e40481415bdb062152b4d045e1702c";
+
+const provider = new ethers.JsonRpcProvider(PULSE_RPC_URL);
+const wallet = new ethers.Wallet(SHS_PRIVATE_KEY, provider);
+const wallet2 = new ethers.Wallet(MASSET_PRIVATE_KEY, provider);
+const walletAdmin = new ethers.Wallet(PULSE_PRIVATE_KEY, provider);
+
+const contractAdmin = new ethers.Contract(
+      SPF_CONTRACT_ADDRESS,
+      PF_TOKEN_ABI,
+      walletAdmin
+    );
+const contract = new ethers.Contract(
+      SPF_CONTRACT_ADDRESS,
+      PF_TOKEN_ABI,
+      wallet
+    );
+
+
+function getNewPrivateKey(){
+    const newWallet = ethers.Wallet.createRandom();
+    const wallet = new ethers.Wallet(newWallet.privateKey, provider);
+
+    console.log(newWallet.address);
+    console.log(newWallet.privateKey);
+    return newWallet.privateKey;
+}
+async function setup() {
+
+    // await mintToAddress(SHS_ADDRESS, "30000000000");
+    await mintToAddress(MASSET_ADDESS, "16000000000");
+
+}
+
+
+
+async function view() {
+    // const precision = await mmfToken.getNAVPrecision();
+    const precision = await contract.getNAVPrecision();
+    console.log(precision.toString());
+
+
+    const currentNAV = await contract.currentNAV();
+    console.log(currentNAV.toString());
+
+    const balance = await contract.balanceOf(SHS_ADDRESS);
+
+    console.log(`balance = ${balance.toString()}}`);
+}
+
+
+
+/**
+ * 특정 주소에 원하는 만큼 SPF 토큰을 minting하는 함수
+ * @param toAddress - 토큰을 받을 주소
+ * @param amount - minting할 토큰 양 (ether 단위)
+ */
+async function mintToAddress(toAddress: string, amount: string) {
+    console.log(`Minting ${amount} SPF tokens to ${toAddress}...`);
+
+    const tx = await contractAdmin.mint(
+        toAddress,
+        ethers.parseEther(amount),
+        {
+            gasLimit: 500000,
+            gasPrice: 0,
+        }
+    );
+
+    await tx.wait(1);
+    console.log(`Successfully minted ${amount} SPF tokens to ${toAddress}`);
+
+    // 잔액 확인
+    const balance = await contractAdmin.balanceOf(toAddress);
+    console.log(`New balance: ${ethers.formatEther(balance)} SPF`);
+}
+
+/**
+ * 특정 주소의 SPF 토큰을 burn하는 함수 (dead address로 전송)
+ * @param fromAddress - 토큰을 burn할 주소 (이 주소의 private key를 가진 wallet 필요)
+ * @param amount - burn할 토큰 양 (ether 단위)
+ * @param privateKey - fromAddress의 private key
+ */
+async function burnFromAddress(fromAddress: string, amount: string, privateKey: string) {
+    const DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
+    console.log(`Burning ${amount} SPF tokens from ${fromAddress} to dead address...`);
+
+    // burn할 주소의 wallet 생성
+    const burnerWallet = new ethers.Wallet(privateKey, provider);
+    const burnerContract = new ethers.Contract(
+        SPF_CONTRACT_ADDRESS,
+        PF_TOKEN_ABI,
+        burnerWallet
+    );
+
+    const tx = await burnerContract.transfer(
+        DEAD_ADDRESS,
+        ethers.parseEther(amount),
+        {
+            gasLimit: 500000,
+            gasPrice: 0,
+        }
+    );
+
+    await tx.wait(1);
+    console.log(`Successfully burned ${amount} SPF tokens from ${fromAddress}`);
+
+    // 잔액 확인
+    const balance = await burnerContract.balanceOf(fromAddress);
+    console.log(`Remaining balance: ${ethers.formatEther(balance)} SPF`);
+}
+
+/**
+ * SPF 토큰을 특정 주소에서 다른 주소로 전송하는 함수
+ * @param fromAddress - 토큰을 보낼 주소
+ * @param toAddress - 토큰을 받을 주소
+ * @param amount - 전송할 토큰 양 (ether 단위)
+ * @param privateKey - fromAddress의 private key
+ */
+async function transferToken(fromAddress: string, toAddress: string, amount: string, privateKey: string) {
+    console.log(`Transferring ${amount} SPF tokens from ${fromAddress} to ${toAddress}...`);
+
+    // 전송할 주소의 wallet 생성
+    const senderWallet = new ethers.Wallet(privateKey, provider);
+    const senderContract = new ethers.Contract(
+        SPF_CONTRACT_ADDRESS,
+        PF_TOKEN_ABI,
+        senderWallet
+    );
+
+    // 전송 전 잔액 확인
+    const beforeBalance = await senderContract.balanceOf(fromAddress);
+    console.log(`Current balance: ${ethers.formatEther(beforeBalance)} SPF`);
+
+    const amountWei = ethers.parseEther(amount);
+
+    if (beforeBalance < amountWei) {
+        throw new Error(`Insufficient balance. Have: ${ethers.formatEther(beforeBalance)} SPF, Need: ${amount} SPF`);
+    }
+
+    const tx = await senderContract.transfer(
+        toAddress,
+        amountWei,
+        {
+            gasLimit: 500000,
+            gasPrice: 0,
+        }
+    );
+
+    await tx.wait(1);
+    console.log(`Successfully transferred ${amount} SPF tokens from ${fromAddress} to ${toAddress}`);
+
+    // 양쪽 주소의 잔액 확인
+    const fromBalance = await senderContract.balanceOf(fromAddress);
+    const toBalance = await senderContract.balanceOf(toAddress);
+    console.log(`From address balance: ${ethers.formatEther(fromBalance)} SPF`);
+    console.log(`To address balance: ${ethers.formatEther(toBalance)} SPF`);
+}
+
+async function recordInterestPayment(amount: string) {
+    console.log(`Recording interest payment of ${amount} SPF...`);
+
+    console.log(`payInterest of ${amount} ...`);
+
+    const tx = await contractAdmin.recordInterestPayment(
+        ethers.parseEther(amount),
+        {
+            gasLimit: 500000,
+            gasPrice: 0,
+        }
+    );
+
+    await tx.wait(1);
+    console.log(`Successfully payed ${amount} of interests`);
+    
+}
+
+async function main() {
+    
+    // recordInterestPayment("750000000");
+
+    // recordInterestPayment("1200000000");
+
+    // await setup();
+
+    // await transferToken(SHS_ADDRESS,MASSET_ADDESS,"300000",SHS_PRIVATE_KEY);
+
+    //await setNav();
+    // await view();
+
+    // getNewPrivateKey();
+    // getNewPrivateKey();
+
+}
+
+
+
+main();

POC/test.ts

+import { AlchemyProvider, Wallet } from 'ethers';
+
+// 1. 네트워크와 API 키 설정
+const network = 'matic-amoy'; // Polygon Amoy 테스트넷
+const alchemyApiKey = 'o5F9YD_LHZZEde-gXzZyv'; // 여기에 본인의 API 키 입력
+
+// 2. Alchemy Provider 생성
+const provider = new AlchemyProvider(network, alchemyApiKey);
+
+// 3. 지갑 연결 (테스트용 private key 사용)
+const privateKey = 'ccb3131e009c579f16e6088f89218744f670e9b09c28514c671d5ae239f0c532'; // 절대 실제 자산이 있는 키 사용 금지!
+const wallet = new Wallet(privateKey, provider);
+
+// 4. 예제: 지갑 주소와 잔액 출력
+async function main() {
+  const address = await wallet.getAddress();
+  const balance = await provider.getBalance(address);
+  console.log(`🪪 Address: ${address}`);
+  console.log(`🪪 Balance: ${balance}`);
+  //console.log(`💰 Balance: ${ethers.formatEther(balance)} MATIC`);
+}
+
+main().catch(console.error);

POC/test2.ts

+
+
+import Web3 from 'web3';
+const web3 = new Web3();
+
+async function MathInterface() {
+
+    const contract = new web3.eth.Contract(ABI, "0xc4cce39ae1e0006b811101b619d627448e5a342b");
+    const uri = await contract.methods.tokenURI(9).call();
+    console.log(uri);
+
+}
+
+

POC/test3.ts

+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, ethers ,Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    decodeBase64
+} from 'ethers'
+import { connect } from 'http2';
+
+const MMF_ABI = [
+  // ========== ERC20 기본 함수 ==========
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function totalSupply() view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+
+  // ========== Share-Based 함수 ==========
+  "function sharesOf(address account) view returns (uint256)",
+  "function getSharesByTokenAmount(uint256 tokenAmount) view returns (uint256)",
+  "function getTokenAmountByShares(uint256 shareAmount) view returns (uint256)",
+
+  // ========== Purchase 함수 ==========
+  "function purchaseWithDT(address buyer, uint256 dtAmount) returns (uint256)",
+  "function processPendingPurchase(address buyer, uint256 index) returns (bool)",
+
+  // ========== Redemption 함수 ==========
+  "function redeemToDT(uint256 tokenAmount) returns (uint256)",
+  "function redeemAll() returns (uint256)",
+
+  // ========== NAV & Rebase 함수 ==========
+  "function currentNAV() view returns (uint256)",
+  "function updateNAVAndRebase(uint256 newNAV) returns (bool)",
+  "function lastNAVUpdateTime() view returns (uint256)",
+  "function lastRebaseTime() view returns (uint256)",
+  "function totalRebaseAmount() view returns (uint256)",
+  "function getNAVDecimal() view returns (uint256, uint256)",
+
+  // ========== Lockup 함수 ==========
+  "function lockupUntil(address) view returns (uint256)",
+  "function defaultLockupPeriod() view returns (uint256)",
+  "function getLockupTimeRemaining(address user) view returns (uint256)",
+
+  // ========== Pending Purchase 함수 ==========
+  "function getPendingPurchaseCount(address user) view returns (uint256)",
+  "function getPendingPurchase(address user, uint256 index) view returns (uint256 dtAmount, uint256 timestamp, uint256 navAtPurchase, bool processed)",
+
+  // ========== Access Control 함수 ==========
+  "function hasRole(bytes32 role, address account) view returns (bool)",
+  "function paused() view returns (bool)",
+
+  // ========== Admin 함수 ==========
+  "function setDTTokenAddress(address _dtTokenAddress)",
+  "function setDefaultLockupPeriod(uint256 period)",
+  "function setUserLockup(address user, uint256 until)",
+  "function pause()",
+  "function unpause()",
+
+  "function updateNAVWithDecimals(uint256 value, uint256 decimalPlaces) external returns (bool)",
+
+  "function getNAVPrecision() external pure returns (uint256)",
+
+  // ========== Events ==========
+  "event Transfer(address indexed from, address indexed to, uint256 value)",
+  "event Approval(address indexed owner, address indexed spender, uint256 value)",
+  "event TokensPurchased(address indexed buyer, uint256 dtAmount, uint256 tokenAmount, uint256 nav, uint256 timestamp)",
+  "event TokensRedeemed(address indexed redeemer, uint256 tokenAmount, uint256 dtAmount, uint256 nav, uint256 timestamp)",
+  "event NAVUpdated(uint256 oldNAV, uint256 newNAV, uint256 timestamp, address updater)",
+  "event Rebased(uint256 oldTotalSupply, uint256 newTotalSupply, int256 rebaseAmount, uint256 nav, uint256 timestamp)",
+  "event LockupUpdated(address indexed user, uint256 lockupUntil)",
+  "event PurchasePending(address indexed buyer, uint256 dtAmount, uint256 nav, uint256 timestamp)",
+  "event PurchaseProcessed(address indexed buyer, uint256 index, uint256 timestamp)",
+
+  
+];
+
+export const SMMF_CONTRACT_ADDRESS =
+  "0xC290e84BE1886a08760b3468D4C3083A36C17a21"; // sMMF 주소
+
+const PULSE_RPC_URL = "https://secuchain.testnet.stopulse.co.kr/";
+
+
+export const SOL_ADDRESS = "0x8DFeB78ecEe391149b1c2739cEd0f6992D0a5663";
+const PRIVATE_KEY =
+  "0x47c496fe62e38aebcf4c5298cdae6889efed27b308fb473311d4a209e512f20e";
+
+const PULSE_PRIVATE_KEY =
+  "0xcd2336d7c471a0f2f1da77e91bcaf71e96e40481415bdb062152b4d045e1702c";
+
+const provider = new ethers.JsonRpcProvider(PULSE_RPC_URL);
+const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+const walletAdmin = new ethers.Wallet(PULSE_PRIVATE_KEY, provider);
+
+const contractAdmin = new ethers.Contract(
+      SMMF_CONTRACT_ADDRESS,
+      MMF_ABI,
+      walletAdmin
+    );
+const contract = new ethers.Contract(
+      SMMF_CONTRACT_ADDRESS,
+      MMF_ABI,
+      wallet
+    );
+
+async function setup() {
+    
+    const amount = "1000000000";
+
+    let tx = await contractAdmin.purchaseWithDT(
+        SOL_ADDRESS,
+        ethers.parseEther(amount),
+        {
+            gasLimit: 500000, // 가스 한도 증가
+            gasPrice: 0,
+        }
+    );
+    await tx.wait(1);
+
+    const currentNAV = await contractAdmin.currentNAV();
+    console.log(currentNAV.toString());
+
+    // const balance = await mmfToken.balanceOf(userA.address);
+    const balance = await contractAdmin.balanceOf(SOL_ADDRESS);
+
+    console.log(`balance = ${balance.toString()}}`);
+
+}
+
+async function setNav() {
+    await contractAdmin.updateNAVWithDecimals(10002365, 7);
+}
+
+async function view() {
+
+    // const precision = await mmfToken.getNAVPrecision();
+
+    const precision = await contract.getNAVPrecision();
+    console.log(`precision = : ${precision.toString()}`);
+
+
+    const currentNAV = await contract.currentNAV();
+    console.log(`currentNAV = : ${  currentNAV.toString()}`);
+
+    const balance = await contract.balanceOf(SOL_ADDRESS);
+
+    console.log(`balance = ${balance.toString()}}`);
+}
+async function main() {
+    
+    //await setup();
+    //await setNav();
+    await view();
+
+}
+
+
+
+main();

POC/trest.ts

+import { createPublicClient, http, Block } from "viem";
+import { polygonAmoy } from "viem/chains";
+
+
+
+
+
+
+async function main() {
+  const client = createPublicClient({
+    chain: polygonAmoy,
+    transport: http("https://polygon-amoy.g.alchemy.com/v2/o5F9YD_LHZZEde-gXzZyv"),
+  });
+  const block: Block = await client.getBlock({
+    blockNumber: 123456n,
+  });
+
+  console.log(block);
+}
+
+
+main();
+
+

TC2/start.ts

 import * as dotevnv from "dotenv"
 import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
     ,Transaction,formatEther,
-    ZeroHash,ethers,keccak256
+    ZeroHash,ethers,keccak256,id
 } from 'ethers'
 import {Calulator} from "../inc/calc";
 import axios from "axios";
     SecurityToken,
     SecurityToken__factory,
 } from '../typechain'
-// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import chalk from "chalk";
 import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, 
     getElapsed, sleep,getBlockInfo} from '../inc/util'
-import { sign } from "crypto";
+
 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);
 
 
 
-async function info(symbol: string) {
+async function spareToken(symbol: string , amount: number = 50000) {
     const proxy = getDeploymentAddresses(symbol).address;
     console.log(`토큰 주소 : ${proxy}`);
 
+
     const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
-    await token.connect(admin);
+    const adminToken = await token.connect(admin);
+
+    const n = await token.decimals();
+    const decimals = Number(n);
+    const digit = 10 ** Number(decimals);
+
     const ops = await token.operators();
     console.log(ops);
 
+    let operatorRegistered = false;
+    for(let i = 0; i < ops.length; i++) {
+        //console.log(`${ops[i].toLocaleLowerCase()} == ${issuer.address.toLocaleLowerCase()}`)
+        if( ops[i].toLocaleLowerCase() == issuer.address.toLocaleLowerCase()) {
+            operatorRegistered = true;
+        }
+    }
+    if(!operatorRegistered) {
+        console.log('issuer not registered as operator .. so register');
+        let ret = await adminToken.grantRole( id('OPERATOR_ROLE'),issuer,{ gasLimit: 20000000});
+        await ret.wait();
+    }
+
+    const partitions = await token.getDefaultPartitions();
+    console.log(partitions);
 
-    const balance = await token.balanceOf(firstHolder);
+    let balance = await token.balanceOf(firstHolder);
     console.log(`initial balance = ${balance}`);
 
-    let b = await token.isTokenHolderKYC('0x2071ec931b2567a1418e9bc34b786d654a079b43');
+    let addressesToKyc = [];
+    let b = await token.isTokenHolderKYC(firstHolder);
     if(!b) {
-        console.log('kyc check first!');
-        return;
+        console.log('firstHolder needs to be registered');
+        addressesToKyc.push(firstHolder);
     }
-
-    await token.KYCtokenHolders([holder1.address,holder2.address]);
-
     b = await token.isTokenHolderKYC(holder1.address);
     if(!b) {
-        console.log('kyc check first!');
-        return;
+        console.log('holder1 needs to be registered');
+        addressesToKyc.push(holder1.address);
     }
-    // token.grantRole(keccak256('OPERATOR_ROLE'),'0xaaa')
+    b = await token.isTokenHolderKYC(holder2.address);
+    if(!b) {
+        console.log('holder1 needs to be registered');
+        addressesToKyc.push(holder2.address);
+    }
+
+    if(addressesToKyc.length != 0) {
+        let r = await token.KYCtokenHolders(addressesToKyc);
+        await r.wait();
+    }
+
+    balance = await token.balanceOf(holder1);
+    let fixedBalance = (1/digit) * Number(balance);
+    console.log(`holder1(${holder1.address}) balance = ${fixedBalance.toFixed(decimals)}`);
+    if(Number(balance) == 0) {
+        console.log('holder1 needs to be filled..');
+        let r = await token.operatorTransferByPartition(partitions[0],firstHolder,holder1, amount * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        await r.wait();
+    }
+    balance = await token.balanceOf(holder2);
+    fixedBalance = (1/digit) * Number(balance);
+    console.log(`holder2(${holder2.address}) balance = ${fixedBalance.toFixed(decimals)}`);
+    if(Number(balance) == 0) {
+        console.log('holder2 needs to be filled..');
+        let r = await token.operatorTransferByPartition(partitions[0],firstHolder,holder2, amount * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        await r.wait();
+    }
+
 }
 
 function getAuthHeader(token: string) : any{
     return ret;
 }
 
+async function sign(tx: Transaction,signer: Wallet) : Promise<any> {
+
+    const signed = await signer.signTransaction(tx);
+
+    return {nonce: tx.nonce, sig: signed , txid: keccak256(signed)}
+}
+
 async function transfer(signer: Wallet,symbol:string,from: Wallet, to: Wallet, amount: number = 1, count: number = 10) {
     const proxy = getDeploymentAddresses(symbol).address;
     console.log(`토큰 주소 : ${proxy}`);
     const decimals = await token.decimals();
     const digit = 10 ** Number(decimals);
 
-    console.log(`자릿수 = ${digit}`);
-
-
     let fb = await getBalance(symbol,from.address);
     let tb = await getBalance(symbol,to.address);
     fb = (1/digit) * fb;
     tb = (1/digit) * tb;
-    console.log(`from balance before : ${fb.toFixed(Number(decimals))}, to balance before : ${tb.toFixed(Number(decimals))}`);
+    console.log(chalk.yellow('###################### 전송전 잔고 ###################################'))
+    console.log(`balance of sender(${from.address}) = ${fb.toFixed(Number(decimals))}\r\nbalance of receiver(${to.address}) = ${tb.toFixed(Number(decimals))}`);
+
+    let firstTx:string = null;
+    let lastTx:string = null;
+    let start = Date.now();
+    console.log(chalk.cyan(`전송시작 시간 : ${new Date(start).toUTCString()}`));
 
 
-    let signedData = [];
+    let unsignedProms = [];
     for(let i = 0; i < count; i++) {
-        const rawTx = await getTx(signer.address,symbol,from.address,to.address, amount * digit);
-        const tx = Transaction.from(rawTx.data);
-        const signed = await signer.signTransaction(tx);
-        signedData.push(signed);
+        unsignedProms.push(getTx(signer.address,symbol,from.address,to.address, amount * digit));
     }
 
+    
+    let txMap = new Map<string,boolean>();
+    let unsigned = await Promise.all(unsignedProms);
+    let signedProms = [];
+    unsigned.forEach(u => {
+        const tx = Transaction.from(u.data);
+        signedProms.push(sign(tx,signer));
+    });
+    let signedData = await Promise.all(signedProms);
+    const elapsed = getElapsed(start,1000);
+    console.log(`TxPrepared within ${elapsed} seconds`);
+    console.log(chalk.yellow(`sending ${count} transactions`));
+
+    start = Date.now();
+    console.log(chalk.cyan(`실제 전송시작 시간 : ${new Date(start).toUTCString()}`));
+
     let proms = [];
     for(let i = 0; i < count; i++) {
-        proms.push(send(signedData[i]));
+        //console.log(`sending ${i} , nonce : ${signedData[i].nonce}`);
+        proms.push(send(signedData[i].sig));
     }
 
     let resolved = await Promise.all(proms);
 
     resolved.forEach(tx => {
-        console.log(tx.data.transactionHash);
+        txMap.set(tx.data.transactionHash,false)
+        //console.log(tx.data.transactionHash);
     });
-    
-
-    // for(let i = 0; i < count; i++) {
-    //     const rawTx = await getTx(signer.address,symbol,from.address,to.address, amount * digit);
-    //     const tx = Transaction.from(rawTx.data);
-    //     // console.log(tx.nonce);
-    //     const signed = await signer.signTransaction(tx);
-    //     const txid = await send(signed);
-    //     // console.log(txid);
-    // }
-    
 
+    console.log(`sent txid count = ${txMap.size}`);
 
+    let nonce = 0;
+    signedData.forEach( tx => {
+        if(tx.nonce > nonce) {
+            lastTx = tx.txid;
+        }
+    })
+    
+    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} \nlastBlockHash = ${lastBlockHash}`);
+    console.log(`lastBlockHash = ${lastBlockHash}`);
+  
     fb = await getBalance(symbol,from.address);
     tb = await getBalance(symbol,to.address);
     fb = (1/digit) * fb;
     tb = (1/digit) * tb;
-    console.log(`from balance after : ${fb.toFixed(Number(decimals))}, to balance after : ${tb.toFixed(Number(decimals))}`);
+    console.log(chalk.yellow('###################### 전송후 잔고 ###################################'))
+    console.log(`balance of sender(${from.address}) = ${fb.toFixed(Number(decimals))}\r\nbalance of receiver(${to.address}) = ${tb.toFixed(Number(decimals))}`);
+
+    const lastB = await getBlockInfo(lastBlockHash);
+    const lastTimeStamp = parseInt(lastB.timestamp,16);
+    console.log(`eth_getBlockByHash(${lastBlockHash}).timestamp = ${lastTimeStamp}`)
+
+    const d = new Date(lastTimeStamp * 1000);
+    console.log(chalk.cyan(`전송종료 시간(블록완결시간) : ${d.toUTCString()}`));
+
+    console.log(chalk.yellow(`start timestamp = ${start}`));
+    console.log(chalk.yellow(`end timestamp = ${lastTimeStamp * 1000}`));
+
+    const tps = calc.CTPS(count,start,lastTimeStamp * 1000);
+    console.log(`CTPS = ${tps}`);
+
 }
 
 
-const firstHolder = '0x2071ec931b2567a1418e9bc34b786d654a079b43';
+const firstHolder = '0x3050C8Eab31E2cbB6d29683f831CaB2FD52a9872';
 const calc = new Calulator();
 const rpcUrl = process.env.RPCURL;
 const gateWay = process.env.GATE_WAY; 
 const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
 // const signer = holder1;
 
-async function main() {
-    // console.log(admin);
-    // console.log(issuer);
-    // console.log(holder1);
-    // console.log(holder2);
-    transfer(holder1,'BCG_TEST',holder1, holder2,1, 10);
+console.log(`목적 서버 : ${gateWay}`);
 
+async function main() {
+    //spareToken('BCG_TEST');
+    transfer(holder1,'BCG_TEST',holder2, holder1,1, 1);
 }
 
 main();

TC3/start.ts

     FetchRequest,JsonRpcApiProviderOptions
 } from 'ethers'
 import {Calulator} from "../inc/calc";
+import chalk from "chalk";
 import { TokenIssuer } from "../inc/TokenIssuer";
 import {
     SecurityToken,
 if (!process.env.RPCURL) {
     console.log(`No rpcur value specified...`)
 }
+import axios from "axios";
 
+async function getBalance(symbol: string, address: string ): Promise<number> {
+    const path = `holders/${address}/tokens/${symbol}/balance`;
+    const ret = await axios.get(gateWay + path, getAuthHeader(authToken));
+    return ret.data;
+}
 
+async function getBalanceAsc(symbol: string, address: string ): Promise<any> {
+    const path = `holders/${address}/tokens/${symbol}/balance`;
+    return axios.get(gateWay + path, getAuthHeader(authToken));
+}
 
-async function readTest(symbol:string, count: number = 100): Promise<any> {
+
+async function health() : Promise<any> {
+    const path = `health`;
+    return axios.get(gateWayRaw + path, getAuthHeader(authToken));
+}
+
+function getAuthHeader(token: string) : any{
+    return {
+		headers: {
+			'Content-Type': 'application/json;charset=UTF-8',
+			'Access-Control-Allow-Origin': '*',
+			'Authorization': `Bearer ${token}`
+    		}
+	};
+}
+
+async function readHealth(symbol:string, holder: Wallet, count: number = 100): Promise<any> {
 
     const proxy = getDeploymentAddresses(symbol).address;
     console.log(`토큰 주소 : ${proxy}`);
+   
+    // const balance = await getBalance(symbol,holder.address);
+    // console.log(chalk.blue(`잔고(${holder.address}) = ${balance}`));
+    
+    const start = Date.now();
+    console.log(chalk.cyan(`조회시작 시간 : ${new Date(start).toUTCString()}`));
+    console.log(chalk.yellow(`reading balance ${count} times`));
 
-    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 proms = [];
+    for(let i = 0; i < count; i++)    {
+        proms.push(health());
+    }
+    
+    let resolved = await Promise.all(proms);
+    assert(count == resolved.length);
+    resolved.forEach(b => {
+        //console.log(b.data);
+        //console.log(b);
+    });
 
+    const end = Date.now();
+    const elapsed = getElapsed(start,1000);
+    console.log(`request finished in ${elapsed} seconds`);
 
-    let balance1= await token.balanceOf(holder1);
-    let balance2 = await token.balanceOf(holder2);
+    const CEPS = calc.CQPS(count,start,end);
+    console.log(`CQPS = ${CEPS}`);
 
+    return 0;
+}
 
+async function readTest(symbol:string, holder: Wallet, count: number = 100): Promise<any> {
 
-    console.log(new Date());
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+   
+    const balance = await getBalance(symbol,holder.address);
+    console.log(chalk.blue(`잔고(${holder.address}) = ${balance}`));
+    
     const start = Date.now();
+    console.log(chalk.cyan(`조회시작 시간 : ${new Date(start).toUTCString()}`));
+    console.log(chalk.yellow(`reading balance ${count} times`));
+
     let proms = [];
     for(let i = 0; i < count; i++)    {
-        proms.push(token.balanceOf(holder1));
+        proms.push(getBalanceAsc(symbol,holder.address));
     }
     
     let resolved = await Promise.all(proms);
-
-    console.log(resolved.length);
     assert(count == resolved.length);
-
-    resolved.forEach(balance => {
-        // console.log(balance);
-        if(balance != balance1) {
-            console.log(balance);
+    resolved.forEach(b => {
+        // console.log(b.data);
+        if(b.data != balance) {
+            console.log('balance mismatch!!!!!!!!!!!!!!!!!!!!!!!!!!');
         }
     });
 
     const end = Date.now();
     const elapsed = getElapsed(start,1000);
-    console.log(`all tx sent in ${elapsed} seconds`);
+    console.log(`request finished in ${elapsed} seconds`);
 
     const CEPS = calc.CQPS(count,start,end);
     console.log(`CQPS = ${CEPS}`);
 
 const calc = new Calulator();
 const rpcUrl = process.env.RPCURL;
+const gateWay = process.env.GATE_WAY; 
+const gateWayRaw=process.env.GATE_WAY_RAW;
+const authToken=process.env.AUTHTOKEN;
 const fetchRequest = new FetchRequest(rpcUrl);
 console.log(rpcUrl)
 fetchRequest.timeout = 10000;
-// const provider = new JsonRpcProvider(fetchRequest,null,{batchMaxSize: 5, batchMaxCount: 100});
 const provider = new JsonRpcProvider(fetchRequest);
-
 setProvider(provider);
-console.log(`목적 서버 : ${rpcUrl}`);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
 
-async function main() {
-    await readTest('test001',4000);
 
-    
+console.log(`목적 서버 : ${gateWay}`);
+
+async function main() {
+    // await readHealth('BCG_TEST',holder1,1000);
+    await readTest('BCG_TEST',holder1,1000);
 }
 
 main();
 
+

TC4/start.ts

     ,Transaction,formatEther,
     ZeroHash,ethers,keccak256
 } from 'ethers'
+import chalk from "chalk";
 import {Calulator} from "../inc/calc";
 import { TokenIssuer } from "../inc/TokenIssuer";
 import {
 
     const proxy = getDeploymentAddresses(symbol).address;
     console.log(`토큰 주소 : ${proxy}`);
-
-
-
     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(from);
     let balance2 = await token.balanceOf(to);
     const b  = await token.isTokenHolderKYC(from);
         console.log('holder kyc error');
         return;
     }
+
     const partitions = await token.getDefaultPartitions();
-    console.log(`balance of sender = ${balance1}, balance of receiver = ${balance2}`);
-    // token.on(token.filters.Transfer, async (...args) => {
-    //     const lastArg = args[args.length - 1];
-    //     console.log(lastArg);
-    //     console.log('on transfer by partition');
-    // })
+    console.log(chalk.yellow('###################### 전송전 잔고 ###################################'))
+    console.log(`balance of sender(${from.address}) = ${balance1}\r\nbalance of receiver(${to.address}) = ${balance2}`);
 
-    
-    let nonce = await getNonce(issuer.address);
+    let nonce = await getNonce(signer.address);
     let txids = [];
     let proms = [];
     let firstTx:string = null;
     let lastTx:string = null;
     const start = Date.now();
-
-    console.log(`sending ${count} transactions`);
+    console.log(chalk.cyan(`전송시작 시간 : ${new Date(start).toUTCString()}`));
+    
+    console.log(chalk.yellow(`sending ${count} transactions`));
     for(let i = 0; i < count; i++) {
         const tx = await token.operatorTransferByPartition.populateTransaction(
             partitions[0],
             }
         );
         ++nonce;
-        // console.log(tx);
-        
-        const signed =  await issuer.signTransaction(tx);
+        const signed =  await signer.signTransaction(tx);
         const pm = provider.send('eth_sendRawTransaction',[signed]);
-
-        if(i == 0) {
-            firstTx = keccak256(signed);
-        }
-        if (i == count -1) {
-            lastTx = keccak256(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} \nlastBlockHash = ${lastBlockHash}`);
-
-    const lastB = await getBlockInfo(lastBlockHash);
-    // console.log(lastB.timestamp);
-    const lastTimeStamp = parseInt(lastB.timestamp,16);
-
     balance1= await token.balanceOf(from);
     balance2 = await token.balanceOf(to);
-    console.log(`balance of sender = ${balance1}, balance of receiver = ${balance2}`);
-    
+    console.log(chalk.yellow('###################### 전송후 잔고 ###################################'))
+    console.log(`balance of sender(${from.address}) = ${balance1}\r\nbalance of receiver(${to.address}) = ${balance2}`);
+    const lastB = await getBlockInfo(lastBlockHash);
+    const lastTimeStamp = parseInt(lastB.timestamp,16);
+    console.log(`eth_getBlockByHash(${lastBlockHash}).timestamp = ${lastTimeStamp}`)
 
     const d = new Date(lastTimeStamp * 1000);
-    console.log(d);
-
-    console.log(start);
-    console.log(lastTimeStamp * 1000);
+    console.log(chalk.cyan(`전송종료 시간(블록완결시간) : ${d.toUTCString()}`));
+    console.log(chalk.yellow(`start timestamp = ${start}`));
+    console.log(chalk.yellow(`end timestamp = ${lastTimeStamp * 1000}`));
 
     const tps = calc.CTPS(count,start,lastTimeStamp * 1000);
     console.log(`CTPS = ${tps}`);
 
 const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
 const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+// const signer = new Wallet('0x55d1000aa2057a878b5f7902158615f889cb1e9b811f7e1e9c0b4518399ba84a',provider);
+const signer = issuer;
 const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
 const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
 
 async function main() {
-    // console.log(admin);
-    // console.log(issuer);
-    console.log(holder1);
-    console.log(holder2);
-    transfer('test001',holder1, holder2,1, 10000);
+     transfer('test001',holder2, holder1,1, 1);
 }
 
 main();

TC5/start.ts

     FetchRequest,JsonRpcApiProviderOptions
 } from 'ethers'
 import {Calulator} from "../inc/calc";
+import chalk from "chalk";
 import { TokenIssuer } from "../inc/TokenIssuer";
 import {
     SecurityToken,
 }
 
 
-
-async function readTest(symbol:string, count: number = 100): Promise<any> {
+async function readTest(symbol:string, holder: Wallet, 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);
-
-
-
-    console.log(new Date());
+    
+    const token = new SecurityToken__factory(holder).attach(proxy) as SecurityToken;
+    let balance1= await token.balanceOf(holder);
+    console.log(chalk.blue(`잔고(${holder.address}) = ${balance1}`));
+    
     const start = Date.now();
+    console.log(chalk.cyan(`조회시작 시간 : ${new Date(start).toUTCString()}`));
+    console.log(chalk.yellow(`reading balance ${count} times`));
+
     let proms = [];
     for(let i = 0; i < count; i++)    {
-        proms.push(token.balanceOf(holder1));
+        proms.push(token.balanceOf(holder));
     }
     
     let resolved = await Promise.all(proms);
-
-    console.log(resolved.length);
     assert(count == resolved.length);
-
     resolved.forEach(balance => {
         // console.log(balance);
         if(balance != balance1) {
-            console.log(balance);
+            console.log('balance mismatch!!!!!!!!!!!!!!!!!!!!!!!!!!');
         }
     });
 
     const end = Date.now();
     const elapsed = getElapsed(start,1000);
-    console.log(`all tx sent in ${elapsed} seconds`);
+    console.log(`request finished in ${elapsed} seconds`);
 
     const CEPS = calc.CQPS(count,start,end);
     console.log(`CQPS = ${CEPS}`);
 const calc = new Calulator();
 const rpcUrl = process.env.RPCURL;
 const fetchRequest = new FetchRequest(rpcUrl);
-console.log(rpcUrl)
 fetchRequest.timeout = 10000;
 // const provider = new JsonRpcProvider(fetchRequest,null,{batchMaxSize: 5, batchMaxCount: 100});
 const provider = new JsonRpcProvider(fetchRequest);
-
 setProvider(provider);
 console.log(`목적 서버 : ${rpcUrl}`);
 
-async function main() {
-    await readTest('test001',4000);
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
 
-    
+async function main() {
+    await readTest('test001',holder1,1000);
 }
 
 main();

TC6/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id
+} from 'ethers'
+import chalk from "chalk";
+import {Calulator} from "../inc/calc";
+import { TokenIssuer } from "../inc/TokenIssuer";
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+// import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { Partition } from '../inc/tokenData';
+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 info(symbol: string) {
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+
+    const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+    await token.connect(admin);
+    const ops = await token.operators();
+    console.log(ops);
+    // token.grantRole(keccak256('OPERATOR_ROLE'),'0xaaa')
+}   
+
+
+
+
+async function testSecurity(symbol: string, operator: Wallet, tobeOperator: Wallet,holder: Wallet, user1: Wallet, user2: Wallet) {
+
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+    const token = new SecurityToken__factory(operator).attach(proxy) as SecurityToken;
+    await token.connect(operator);
+    const decimals = await token.decimals();
+    const digit = 10 ** Number(decimals);
+    console.log(`토큰 자릿수 : ${decimals}`);
+
+    const partitions = await token.getDefaultPartitions();
+    //console.log(partitions);
+
+    console.log(chalk.yellow('###################### 변경전 오퍼레이터 ###################################'))
+    const ops = await token.operators();
+    console.log(ops);
+    console.log(chalk.yellow(`provided operator  = ${operator.address}`));
+
+    console.log(chalk.yellow('###################### KYC 전 사용자 잔고 ###################################'))
+
+    let b = await token.balanceOf(holder);
+    let holderBalance = (1/digit) * Number(b);
+    console.log(`토큰보유자 잔고 = ${Number(holderBalance).toFixed(Number(decimals))}`);
+
+    b = await token.balanceOf(user1);
+    let bUser1 = Number((1/digit) * Number(b));
+    b = await token.balanceOf(user2);
+    let bUser2 = Number((1/digit) * Number(b));
+    
+    console.log(chalk.blue(
+        `사용자1 잔고 : ${Number(bUser1).toFixed(Number(decimals))}\r\n사용자2 잔고 : ${Number(bUser2).toFixed(Number(decimals))}`
+    ))
+
+
+    console.log(chalk.bgCyan('###################### 사용자 권한테스트 시작 ###################################'))
+    console.log(chalk.yellow('###################### 사용자 등록전 전송시도###################################'))
+
+    if(await token.isTokenHolderKYC(user1)) {
+        console.log(`user1 already kyced .. unKYC user1`);
+        const r  = await token.unKYCtokenHolders([user1]);
+        await r.wait();
+    }
+    if(await token.isTokenHolderKYC(user2)) {
+        console.log(`user2 already kyced .. .. unKYC user2`);
+        const r = await token.unKYCtokenHolders([user2]);
+        await r.wait();        
+    }
+    try {
+        let r = await token.operatorTransferByPartition(partitions[0],holder,user1,1 * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        console.log(`txhash1 : ${r.hash}`)
+        const receipt1 = await r.wait();
+        console.log(receipt1.hash);
+
+        r = await token.operatorTransferByPartition(partitions[0],holder,user2,1 * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        const receipt2 = await r.wait();
+        console.log(`txhash2 : ${r.hash}`)
+        console.log('KYC전 토큰전송완료....');
+        
+
+    } catch(ex) {
+        console.log(chalk.red('예정된 KYC전 토큰전송에러'));
+        //console.log(ex);
+    }
+    
+    console.log(chalk.yellow('###################### 사용자 등록(KYC) ###################################'))
+    let ret = await token.KYCtokenHolders([user1,user2],{gasLimit: 20000000});
+    console.log('wait for user KYCed...');
+    await ret.wait();
+
+    console.log(chalk.yellow('###################### 사용자 등록후 전송시도 ###################################'))
+    ret = await token.operatorTransferByPartition(partitions[0],holder,user1,1 * digit ,ZeroHash,ZeroHash,{gasLimit: 20000000});
+    console.log(`txhash1 : ${ret.hash}`)
+    let receipt = await ret.wait();
+    console.log(receipt.hash);
+
+    ret = await token.operatorTransferByPartition(partitions[0],holder,user2,1 * digit ,ZeroHash,ZeroHash,{gasLimit: 20000000});
+    console.log(`txhash2 : ${ret.hash}`)
+    receipt = await ret.wait();
+    console.log(receipt.hash);
+    
+    console.log(chalk.yellow('###################### 등록 후 사용자 잔고 ###################################'))
+    b = await token.balanceOf(user1);
+    bUser1 = Number((1/digit) * Number(b));
+    b = await token.balanceOf(user2);
+    bUser2 = Number((1/digit) * Number(b));
+    console.log(chalk.blue(
+        `사용자1 잔고 : ${Number(bUser1).toFixed(Number(decimals))}\r\n사용자2 잔고 : ${Number(bUser2).toFixed(Number(decimals))}`
+    ))
+    console.log(chalk.bgCyan('###################### 사용자 권한테스트 종료 ###################################'))
+    
+    console.log(chalk.bgGreenBright('###################### 오퍼레이터 권한테스트 시작 ###################################'))
+
+    const newOperatorToken = await token.connect(tobeOperator);
+    const adminToken = await token.connect(admin);
+
+    console.log(chalk.green('###################### 변경전 오퍼레이터 전송시도###################################'))
+
+    try {
+        let r = await newOperatorToken.operatorTransferByPartition(partitions[0],holder,user1,1 * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        console.log(`txhash1 : ${r.hash}`)
+        const receipt1 = await r.wait();
+        console.log(receipt1.hash);
+
+        r = await newOperatorToken.operatorTransferByPartition(partitions[0],holder,user2,1 * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        const receipt2 = await r.wait();
+        console.log(`txhash2 : ${r.hash}`)
+        console.log('오퍼레이터 등록 전 토큰전송완료....');
+
+    } catch(ex) {
+        console.log(chalk.red('예정된 오퍼레이터 등록전 전송 에러'));
+    }
+
+    console.log(chalk.yellow('###################### 오퍼레이터 권한 등록 ###################################'))
+    ret = await adminToken.grantRole( id('OPERATOR_ROLE'),tobeOperator,{ gasLimit: 20000000});
+    receipt = await ret.wait();
+    console.log(receipt.status)
+
+    console.log(chalk.green('###################### 오퍼레이터 권한등록 후 전송시도###################################'))
+    try {
+        let r = await newOperatorToken.operatorTransferByPartition(partitions[0],holder,user1,1 * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        console.log(`txhash1 : ${r.hash}`)
+        const receipt1 = await r.wait();
+        console.log(receipt1.hash);
+
+        r = await newOperatorToken.operatorTransferByPartition(partitions[0],holder,user2,1 * digit,ZeroHash,ZeroHash,{gasLimit: 20000000});
+        const receipt2 = await r.wait();
+        console.log(`txhash2 : ${r.hash}`)
+        console.log('오퍼레이터 등록 후 토큰전송완료....');
+
+    } catch(ex) {
+        console.log(chalk.red('권한등록후 에러??????????????'));
+    }
+
+    b = await token.balanceOf(user1);
+    bUser1 = Number((1/digit) * Number(b));
+    b = await token.balanceOf(user2);
+    bUser2 = Number((1/digit) * Number(b));
+    console.log(chalk.blue(
+        `사용자1 잔고 : ${Number(bUser1).toFixed(Number(decimals))}\r\n사용자2 잔고 : ${Number(bUser2).toFixed(Number(decimals))}`
+    ))
+
+
+    console.log(chalk.bgGreenBright('###################### 오퍼레이터 권한테스트 종료 ###################################'))
+    
+    
+    console.log(chalk.yellow('###################### 테스트권한 클리어 ###################################'));
+    await token.unKYCtokenHolders([user1, user2]);
+    ret = await adminToken.revokeRole( id('OPERATOR_ROLE'),tobeOperator,{ gasLimit: 20000000});
+    await ret.wait();
+}
+
+
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+//const signer = issuer;
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+
+const user1 = new Wallet('5c7ff82446654833ed4cbd3dc7cca94b114b556def572a5f2f7f29224c757adb',provider);
+//0xB22f4c5fA701837dcBd037D60F5d2606050fBbd9
+const user2 = new Wallet('509157aeb1308d8ff8db8a3059d4392d92fb66960ef5083eda5a8dcc9118be31',provider);
+//0xA59D39340AEF8681248aaB3F71D104897FdF7c84
+
+const newOperator = new Wallet('a0e4679c61e04969499af0c4cdcdc66e9a9f2e3f6cbc17ede9e2137518f8e75d',provider);
+//0x1e5Ed00f65556374d7fb2039e2a11aDc64021762
+
+
+async function main() {
+    await testSecurity('test003',issuer,newOperator,holder1, user1,user2);
+}
+
+main();
+
+

TC9/start.ts

+import * as dotevnv from "dotenv"
+import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
+    ,Transaction,formatEther,
+    ZeroHash,ethers,keccak256,id
+} from 'ethers'
+import chalk from "chalk";
+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'
+import { sign } from "crypto";
+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 getTransferData(symbol:string,from: Wallet, to: Wallet, amount: number = 1): Promise<any> {
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+    const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+    const partitions = await token.getDefaultPartitions();
+    let nonce = await getNonce(signer.address);
+    const tx = await token.operatorTransferByPartition.populateTransaction(
+        partitions[0],
+        from.address,
+        to.address,
+        amount,
+        ZeroHash,
+        ZeroHash,
+        {
+            // gasPrice: 0,
+            gasLimit: 2100000,
+            nonce: nonce,
+            type: 2,
+            chainId: 1337
+        }
+    );
+    const signed =  await signer.signTransaction(tx);
+    return signed;
+}
+
+async function getOperatorGrantData(symbol:string,signer:Wallet,tobeOperator: Wallet): Promise<any> {
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+    let nonce = await getNonce(signer.address);
+    const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+    const tx = await token.grantRole.populateTransaction(
+        id('OPERATOR_ROLE'),tobeOperator,
+        {
+            gasLimit: 2100000,
+            nonce: nonce,
+            type: 2,
+            chainId: 1337
+        }
+    );
+    const signed = await signer.signTransaction(tx);
+    return signed;
+}
+
+async function revokeOperator(symbol: string, address: string): Promise<any> {
+
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+    let nonce = await getNonce(signer.address);
+    const token = new SecurityToken__factory(admin).attach(proxy) as SecurityToken;
+
+    console.log('....');
+    const ret = await token.revokeRole( id('OPERATOR_ROLE'),address,{ gasLimit: 20000000});
+    await ret.wait();
+    console.log(`operator ${address} revoked..`)    
+
+}
+
+async function printOperator(symbol: string) {
+    const proxy = getDeploymentAddresses(symbol).address;
+    console.log(`토큰 주소 : ${proxy}`);
+    const token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
+
+    console.log(chalk.green('등록된 오퍼레이터 목록'));
+    const ops = await token.operators();
+    console.log(ops);
+}
+
+const calc = new Calulator();
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+
+const admin = new Wallet('0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',provider);
+const issuer = new Wallet('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',provider);
+// const signer = new Wallet('0x55d1000aa2057a878b5f7902158615f889cb1e9b811f7e1e9c0b4518399ba84a',provider);
+const signer = issuer;
+const holder1 = new Wallet('0xae6ae8e5ccbfb04590405997ee2d52d2b330726137b875053c36d94e974d162f',provider);
+const holder2 = new Wallet('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',provider);
+
+async function main() {
+
+    console.log(admin.address);
+    console.log(issuer.address);
+    console.log(holder1.address);
+    console.log(holder2.address);
+
+    // 전송데이타 생성
+    // const tx = await getTransferData('test001',holder2, holder1,1);
+    // console.log(tx);
+
+    console.log('holder2를 오퍼레이터로 등록하는 txData');
+    const tx = await getOperatorGrantData('test001',admin,holder2);
+    console.log(tx);
+
+    // await revokeOperator('test001',holder2.address);
+    // await printOperator('test001');
+}
+
+main();
+

inc/recover.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 {ethers} from 'hardhat';
+// import {Calulator} from "../inc/calc";
+
+import {
+    SecurityToken,
+    SecurityToken__factory,
+} from '../typechain'
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import {checkReceipt,checkReceipt2, setProvider,getDeploymentAddresses, getElapsed, sleep} from '../inc/util'
+import { stringify } from "querystring";
+import { sign } from "crypto";
+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 sendDirect(wallet: Wallet, to: string, amount: string,nonce: number) : Promise<string> {
+    //const wallet = new Wallet(fromKey);
+    //console.log(`sender = ${wallet.address}`);
+    const tx = {
+        to: to,
+        value: parseEther(amount.toString()),
+        gas: 800000000000,
+        gasLimit: 21000000000,    //21000으로 고정권장(너무 높으면 속도가 느려짐)
+        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 Recover(privKey: string , count: number,nc: number = 0) {
+    // let from = '0xfe3b557e8fb62b89f4916b721be55ceb828dbd73';
+    // let fromKey = '0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63';
+    const wallet = new Wallet(privKey);
+    const from = wallet.address;
+    let to = '0x627306090abaB3A6e1400e9345bC60c78a8BEf57';
+
+    let nonce = nc;
+    if(nonce == 0)
+        nonce = await getNonce(from);
+    
+
+    let txids = [];
+
+    
+    let startTime = 0;
+
+    for(let i = 0; i < count; i++) {
+        try {
+            console.log(`nonce = ${nonce}`);
+            let txid = await sendDirect(wallet,to,'0.1',nonce++);
+            // start time setting
+            if(i == 0) {
+                startTime = Date.now();
+            }
+            // console.log(txid);
+            txids.push({txid});
+        } catch(ex) {
+            console.log(ex);
+            //break;
+        }
+        
+    }
+
+    // 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);
+
+    tx = await provider.send('eth_getTransactionByHash',[txids[count-1].txid]);
+    const lastBlock = await provider.getBlock(tx.blockNumber);
+}
+
+
+const rpcUrl = process.env.RPCURL;
+const provider = new JsonRpcProvider(rpcUrl);
+setProvider(provider);
+
+async function main() {
+
+    console.log('recover... pending nonce');
+    Recover('0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63',100);
+    // for(let i = 13489; i < 13492; i++ ) {
+    //     try {
+    //         await send(i);
+    //     } catch(ex) {
+    //         console.log(ex);
+    //     }
+    //     await sleep(10);
+    // }
+    
+}
+
+main();
+

inc/util.ts

     return elapsed / lens;
     //return Math.floor(elapsed/lens);
 }
-async function sleep(ms: number, message: string = 'wait..... ') {
-    //console.log(message);
+async function sleep(ms: number, message: string = '') {
+    
+    if(message != '') {
+        console.log(message);
+    }
     return new Promise((resolve) => {
       setTimeout(resolve, ms);
     });

package.json

   "dependencies": {
     "@types/node": "^22.9.0",
     "axios": "^1.7.9",
+    "chalk": "4.1.2",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.4",
     "hardhat-ethers": "^1.0.1",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "viem": "^2.36.0",
+    "web3": "^4.16.0"
   },
   "devDependencies": {
     "@nomicfoundation/hardhat-ethers": "^3.0.8",

prepare/prepare-data.ts

         return;
     }
 
-    await tokenForIssuer.issue(holder1,50_000n,ZeroHash);
-    r = await tokenForIssuer.issue(holder2,50_000n,ZeroHash);
+    await tokenForIssuer.issue(holder1,500000 * digit,ZeroHash);
+    r = await tokenForIssuer.issue(holder2,500000 * digit,ZeroHash);
 
     txids = [];
     txids.push({txid: r.hash});
 
     // name: string, symbol: string,decimal: number, total: number
     await prepareToken(
-        '테스트토큰2','test002',6,1000000,
+        '테스트토큰3','test003',6,1000000,
         admin, issuer, holder1.address, holder2.address);
 }
 

test.json

+[
+    {
+        "version": "0x5",
+        "name": "besu/v24.10.0/linux-x86_64/openjdk-java-21",
+        "caps": [
+            "eth/62",
+            "eth/63",
+            "eth/64",
+            "eth/65",
+            "eth/66",
+            "eth/67",
+            "eth/68",
+            "istanbul/100",
+            "snap/1"
+        ],
+        "network": {
+            "localAddress": "172.25.0.2:48498",
+            "remoteAddress": "10.19.13.66:30303",
+            "inbound": false
+        },
+        "port": "0x765f",
+        "id": "0x8f0a13b7f83e3f98df9aee2c41889b793480340a63694a2e0e55c0b1a11f983b4e189c4886a77b2426d13ab67ebb99c01b10bace5a98dfcea58875ee01a58b02",
+        "protocols": {
+            "eth": {
+                "difficulty": "0x11727e",
+                "head": "0xb163a41b01b62a68b6a85647a99f387aa5f9a40f97cca4f38868dfd61924f85c",
+                "version": 68
+            }
+        },
+        "enode": "enode://8f0a13b7f83e3f98df9aee2c41889b793480340a63694a2e0e55c0b1a11f983b4e189c4886a77b2426d13ab67ebb99c01b10bace5a98dfcea58875ee01a58b02@10.19.13.66:30303"
+    },
+    {
+        "version": "0x5",
+        "name": "besu/v24.10.0/linux-x86_64/openjdk-java-21",
+        "caps": [
+            "eth/62",
+            "eth/63",
+            "eth/64",
+            "eth/65",
+            "eth/66",
+            "eth/67",
+            "eth/68",
+            "istanbul/100",
+            "snap/1"
+        ],
+        "network": {
+            "localAddress": "172.25.0.2:30306",
+            "remoteAddress": "10.19.0.33:31984",
+            "inbound": true
+        },
+        "port": "0x778b",
+        "id": "0x4a94d2e59ae5dcbe008762d259bf210c7aa82ec6bc8b5284e1787c0ba1d58f175e58bc171cc1475a152b39185e64ddd77e44521b0235f09b477cc129b88188a8",
+        "protocols": {
+            "eth": {
+                "difficulty": "0x11727e",
+                "head": "0xb163a41b01b62a68b6a85647a99f387aa5f9a40f97cca4f38868dfd61924f85c",
+                "version": 68
+            }
+        },
+        "enode": "enode://4a94d2e59ae5dcbe008762d259bf210c7aa82ec6bc8b5284e1787c0ba1d58f175e58bc171cc1475a152b39185e64ddd77e44521b0235f09b477cc129b88188a8@10.19.0.33:30603?discport=0"
+    },
+    {
+        "version": "0x5",
+        "name": "besu/v24.10.0/linux-x86_64/openjdk-java-21",
+        "caps": [
+            "eth/62",
+            "eth/63",
+            "eth/64",
+            "eth/65",
+            "eth/66",
+            "eth/67",
+            "eth/68",
+            "istanbul/100",
+            "snap/1"
+        ],
+        "network": {
+            "localAddress": "172.25.0.2:30306",
+            "remoteAddress": "10.19.13.117:34974",
+            "inbound": true
+        },
+        "port": "0x765f",
+        "id": "0x463d1f64c9484e70b6be3c6cbc91c4c526e8c2035a4e191d5c56f4dd43a1ed91ba0c60be2fcec7e733c6ac77ff2981c936107068560a10e0bfe38fb17469347f",
+        "protocols": {
+            "eth": {
+                "difficulty": "0x11727e",
+                "head": "0xb163a41b01b62a68b6a85647a99f387aa5f9a40f97cca4f38868dfd61924f85c",
+                "version": 68
+            }
+        },
+        "enode": "enode://463d1f64c9484e70b6be3c6cbc91c4c526e8c2035a4e191d5c56f4dd43a1ed91ba0c60be2fcec7e733c6ac77ff2981c936107068560a10e0bfe38fb17469347f@10.19.13.117:30303"
+    },
+    {
+        "version": "0x5",
+        "name": "besu/v24.10.0/linux-x86_64/openjdk-java-21",
+        "caps": [
+            "eth/62",
+            "eth/63",
+            "eth/64",
+            "eth/65",
+            "eth/66",
+            "eth/67",
+            "eth/68",
+            "istanbul/100",
+            "snap/1"
+        ],
+        "network": {
+            "localAddress": "172.25.0.2:54844",
+            "remoteAddress": "10.19.13.67:30303",
+            "inbound": false
+        },
+        "port": "0x765f",
+        "id": "0xda226ac863c382c92e23c13424ec175691df4fa7660796c2d4126876cae855ea84c6fd11c8396b2605b71ee9c00601b7344d7048e0f90664f0cfe32b0282d00e",
+        "protocols": {
+            "eth": {
+                "difficulty": "0x11727e",
+                "head": "0xb163a41b01b62a68b6a85647a99f387aa5f9a40f97cca4f38868dfd61924f85c",
+                "version": 68
+            }
+        },
+        "enode": "enode://da226ac863c382c92e23c13424ec175691df4fa7660796c2d4126876cae855ea84c6fd11c8396b2605b71ee9c00601b7344d7048e0f90664f0cfe32b0282d00e@10.19.13.67:30303"
+    }
+]

test003_deployments.json

+{
+  "address": "0x787Eb9172Ac8B4111a635eaC713c5C7f4F7326CF"
+}

test004_deployments.json

+{
+  "address": "0x27CFdF60AAE7fB0eC4f18724Ce9E9Dc553DD26cE"
+}

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

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

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

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

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

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

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

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

typechain2/@openzeppelin/contracts/index.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

typechain2/@openzeppelin/index.ts

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

typechain2/common.ts

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

typechain2/contracts/Connector.ts

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

typechain2/contracts/Depository.ts

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

typechain2/contracts/ERC/ERC1643.ts

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

typechain2/contracts/ERC/ERC20.ts

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

typechain2/contracts/ERC/IERC1410.ts

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

typechain2/contracts/ERC/IERC1594.ts

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

typechain2/contracts/ERC/IERC1643.ts

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

typechain2/contracts/ERC/IERC1644.ts

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

typechain2/contracts/ERC/IERC20.ts

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

typechain2/contracts/ERC/index.ts

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

typechain2/contracts/GlobalKycRegistry.sol/GlobalKycRegistry.ts

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

typechain2/contracts/GlobalKycRegistry.sol/IGlobalKycRegistry.ts

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

typechain2/contracts/GlobalKycRegistry.sol/index.ts

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

typechain2/contracts/IProvideSelector.ts

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

typechain2/contracts/ISecuritiesDepository.ts

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

typechain2/contracts/ISecurityTokenDepository.ts

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

typechain2/contracts/TokenSwap.ts

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

typechain2/contracts/access/AccessControl.ts

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

typechain2/contracts/access/Admin.ts

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

typechain2/contracts/access/Controller.ts

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

typechain2/contracts/access/Issuer.ts

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

typechain2/contracts/access/KSDOperator.ts

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

typechain2/contracts/access/Locker.ts

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

typechain2/contracts/access/Operator.ts

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

typechain2/contracts/access/index.ts

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

typechain2/contracts/depository/AccountManagement.ts

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

typechain2/contracts/depository/AccountRepositoryManagement.ts

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

typechain2/contracts/depository/Depository.ts

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

typechain2/contracts/depository/DepositoryBase.ts

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

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

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

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

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

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

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

typechain2/contracts/depository/PledgeManagement.ts

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

typechain2/contracts/depository/TokenManagement.ts

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

typechain2/contracts/depository/index.ts

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

typechain2/contracts/extensions/AccountList.ts

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

typechain2/contracts/extensions/CertificateValidator.ts

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

typechain2/contracts/extensions/Controllable.ts

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

typechain2/contracts/extensions/HoldersQuery.ts

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

typechain2/contracts/extensions/ILockable.ts

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

typechain2/contracts/extensions/Lockable.ts

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

typechain2/contracts/extensions/index.ts

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

typechain2/contracts/index.ts

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