TTA-Cert/TC2/start.ts

import * as dotevnv from "dotenv"
import {toUtf8String,parseUnits,ContractFactory, parseEther,JsonRpcProvider, Contract, JsonRpcSigner, Wallet,ContractTransactionResponse, MaxInt256
    ,Transaction,formatEther,
    ZeroHash,ethers,keccak256
} from 'ethers'
import {Calulator} from "../inc/calc";
import axios from "axios";

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 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);


    const balance = await token.balanceOf(firstHolder);
    console.log(`initial balance = ${balance}`);

    let b = await token.isTokenHolderKYC('0x2071ec931b2567a1418e9bc34b786d654a079b43');
    if(!b) {
        console.log('kyc check first!');
        return;
    }

    await token.KYCtokenHolders([holder1.address,holder2.address]);

    b = await token.isTokenHolderKYC(holder1.address);
    if(!b) {
        console.log('kyc check first!');
        return;
    }
    // token.grantRole(keccak256('OPERATOR_ROLE'),'0xaaa')
}

function getAuthHeader(token: string) : any{
    return {
		headers: {
			'Content-Type': 'application/json;charset=UTF-8',
			'Access-Control-Allow-Origin': '*',
			'Authorization': `Bearer ${token}`
    		}
	};
}

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 getTx(signerAddress:string, tokenSymbol: string, from: string, to: string, value: number) : Promise<any> {
    const path = 'transfer/tx/data';
    const ret = await axios.post(gateWay + path, {
        signerAddress,
        tokenSymbol,
        transfers : [{
            partitionName:'초기',
            from,
            to,
            value,
            data:'0x0000000000000000000000000000000000000000000000000000000000000000',
            operatorData:'0x0000000000000000000000000000000000000000000000000000000000000000'
        }]
    },getAuthHeader(authToken));
    return ret;
}

async function send(signedTransaction: string) {
    const path = 'transaction/send';
    const ret = await axios.post(gateWay + path, {
        signedTransaction
    },getAuthHeader(authToken));
    return ret;
}

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 token = new SecurityToken__factory(issuer).attach(proxy) as SecurityToken;
    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))}`);


    let signedData = [];
    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);
    }

    let proms = [];
    for(let i = 0; i < count; i++) {
        proms.push(send(signedData[i]));
    }

    let resolved = await Promise.all(proms);

    resolved.forEach(tx => {
        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);
    // }
    


    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))}`);
}


const firstHolder = '0x2071ec931b2567a1418e9bc34b786d654a079b43';
const calc = new Calulator();
const rpcUrl = process.env.RPCURL;
const gateWay = process.env.GATE_WAY; 
const authToken=process.env.AUTHTOKEN;
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 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);

}

main();