Class ConcordiumGRPCNodeClient

    await client.banPeer(cli.flags.ip);
    console.log('Specified peer successfully banned');

    await client.dumpStart(cli.flags.filepath, cli.flags.dumpRaw);
    console.log('Dump successfully started');

    await client.dumpStop();
    console.log('Dump successfully stopped');

    const accountAddress = AccountAddress.fromBase58(cli.flags.account);
    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const accountInfo: AccountInfo = await client.getAccountInfo(accountAddress, blockHash);

    console.log('Account balance:', accountInfo.accountAmount);
    console.log('Account address:', accountInfo.accountAddress);

    // If the account is a delegator print delegator information
    if (accountInfo.type === AccountInfoType.Delegator) {
        console.log('Delegated stake amount:', accountInfo.accountDelegation.stakedAmount);
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const accounts: AsyncIterable<AccountAddress.Type> = client.getAccountList(blockHash);

    const accountAddress = AccountAddress.fromBase58(cli.flags.account);
    const transactions: AsyncIterable<TransactionHash.Type> = client.getAccountNonFinalizedTransactions(accountAddress);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const ancestors: AsyncIterable<BlockHash.Type> = client.getAncestors(BigInt(cli.flags.maxAncestors), blockHash);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const ars: AsyncIterable<ArInfo> = client.getAnonymityRevokers(blockHash);

    for await (const ar of ars) {
        console.log('Anonymity Revoker ID:', ar.arIdentity);
        console.log('Anonymity Revoker name:', ar.arDescription.name);
        console.log('Anonymity Revoker description:', ar.arDescription.description, '\n');
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const bakerIds: AsyncIterable<BakerId> = client.getBakerList(blockHash);

    const bannedPeers: IpAddressString[] = await client.getBannedPeers();

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const cp: ChainParameters = await client.getBlockChainParameters(blockHash);

    const euroPerEnergy = cp.euroPerEnergy.numerator + '/' + cp.euroPerEnergy.denominator;
    console.log('Account creation limit:', cp.accountCreationLimit);
    console.log('Euro per Energy:', euroPerEnergy);

    // Check version of chain parameters
    if (cp.version === 2) {
        console.log('Minimum block time', cp.minBlockTime);
    } else if (cp.version === 1) {
        console.log('Minimum equity capital:', cp.minimumEquityCapital);
    } else {
        console.log('Chain parameters is V0 and does not contain information on minimum equity capital');
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const summary: BlockFinalizationSummary = await client.getBlockFinalizationSummary(blockHash);

    if (summary.tag === 'record') {
        // Response contains finalization summary for the given block:
        console.log('block:', summary.record.block);
        console.log('index:', summary.record.index);
        console.log('delay:', summary.record.delay);
        console.log('Amount of finalizers:', summary.record.finalizers.length);
    } else {
        console.log('Given block has not been finalized, and no information can be gotten');
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const blockInfo: BlockInfo = await client.getBlockInfo(blockHash);

    const blockItemStatus: BlockItemStatus = await client.getBlockItemStatus(
        TransactionHash.fromHexString(cli.flags.transaction)
    );

    console.log('Status of the transaction:', cli.flags.transaction, '\n');
    // Note that there will be no outcomes for a transaction that has only been received:
    if (blockItemStatus.status === 'received') {
        console.log('blockItemStatus is "received" and therefore has no "status" field');
    }
    // If the transaction has only been committed, then there is a list of outcomes:
    if (blockItemStatus.status === 'committed') {
        console.log('blockItemStatus is "committed" and therefore there are potentially multiple outcomes');
    }
    // If the transaction has been finalized, then there is exactly one outcome:
    if (blockItemStatus.status === 'finalized') {
        console.log('blockItemStatus is "finalized" and therefore there is exactly one outcome \n');

        const { summary } = blockItemStatus.outcome;

        if (summary.type === 'accountTransaction') {
            console.log('The block item is an account transaction');

            switch (summary.transactionType) {
                case 'transfer':
                    // The transaction is a simple transfer
                    const { amount, to } = summary.transfer;
                    const ccdAmount = CcdAmount.toCcd(amount);
                    console.log(ccdAmount, 'CCD sent to', to);
                    break;
                case 'failed':
                    // The transaction was rejected, in which case the transaction
                    // type is still available under the failedTransactionType field
                    const { failedTransactionType, rejectReason } = summary;
                    console.log(
                        'Transaction of type "' + failedTransactionType + '" failed because:',
                        rejectReason.tag
                    );
                    break;
                default:
                    // Another transaction kind encountered
                    const otherType = summary.transactionType;
                    console.log('The transaction is of type:', otherType);
            }
        } else if (summary.type === 'updateTransaction') {
            console.log('The block item is a chain update');

            const { effectiveTime, payload } = summary;
            console.log('EffectiveTime:', effectiveTime);
            console.log('Payload:', payload);
            console;
        } else if (summary.type === 'accountCreation') {
            console.log('The block item is an account creation');
            console.log('Account created with address:', summary.address);
        }
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const pendingUpdates: AsyncIterable<PendingUpdate> = client.getBlockPendingUpdates(blockHash);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const events: AsyncIterable<BlockSpecialEvent> = client.getBlockSpecialEvents(blockHash);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const events: AsyncIterable<BlockItemSummary> = client.getBlockTransactionEvents(blockHash);

    // Get block stream
    const blocks: AsyncIterable<ArrivedBlockInfo> = client.getBlocks();

    // Prints blocks infinitely
    for await (const block of blocks) {
        console.log('Arrived block height:', block.height);
        console.log('Arrived block hash:', block.hash, '\n');
    }

    const blocks: BlockHash.Type[] = await client.getBlocksAtHeight(BigInt(cli.flags.height));

    const branch: Branch = await client.getBranches();

    console.log('Root hash:', branch.blockHash);
    console.log("Root's children:");
    console.dir(branch.children, { depth: null, colors: true });

    const consensusStatus: ConsensusStatus = await client.getConsensusStatus();

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const parameters: CryptographicParameters = await client.getCryptographicParameters(blockHash);

    const moduleRef = ModuleReference.fromHexString(cli.flags.module);
    const schema = await client.getEmbeddedSchema(moduleRef);

    // Get block stream
    const blockStream: AsyncIterable<FinalizedBlockInfo> = client.getFinalizedBlocks();

    // Prints blocks infinitely
    for await (const block of blockStream) {
        console.log('Arrived block height:', block.height);
        console.log('Arrived block hash:', block.hash, '\n');
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const ips: AsyncIterable<IpInfo> = client.getIdentityProviders(blockHash);

    for await (const ip of ips) {
        console.log('Identity Provider ID:', ip.ipIdentity);
        console.log('Identity Provider Description:', ip.ipDescription, '\n');
    }

    const contractAddress = ContractAddress.create(cli.flags.contract);
    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);

    const instanceInfo: InstanceInfo = await client.getInstanceInfo(contractAddress, blockHash);

    console.log('Name:', instanceInfo.name);
    console.log('Amount in CCD:', Number(instanceInfo.amount.microCcdAmount / 1000000n));
    console.log('Version:', instanceInfo.version);
    console.log('Owner:', instanceInfo.owner.address);
    console.log('Module Reference:', instanceInfo.sourceModule.moduleRef);
    console.log('Methods:');
    for (const method of instanceInfo.methods) {
        console.log('    ' + method);
    }

    const contractAddress = ContractAddress.create(cli.flags.contract);
    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const states: AsyncIterable<InstanceStateKVPair> = client.getInstanceState(contractAddress, blockHash);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const moduleRefs: AsyncIterable<ModuleReference.Type> = client.getModuleList(blockHash);

    const ref = ModuleReference.fromHexString(cli.flags.module);
    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const versionedSource = await client.getModuleSource(ref, blockHash);

    const account = AccountAddress.fromBase58(cli.flags.account);
    const nextNonce: NextAccountNonce = await client.getNextAccountNonce(account);

    console.log('Next Nonce:', nextNonce.nonce);
    console.log('Nonce is reliable:', nextNonce.allFinal);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const updateSeqNums: NextUpdateSequenceNumbers = await client.getNextUpdateSequenceNumbers(blockHash);

    const nodeInfo: NodeInfo = await client.getNodeInfo();

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const passiveDelegationInfo: PassiveDelegationStatus = await client.getPassiveDelegationInfo(blockHash);

    console.log('CCD provided by the delegators to the pool:', CcdAmount.toCcd(passiveDelegationInfo.delegatedCapital));
    console.log('Total capital in CCD of ALL pools:', CcdAmount.toCcd(passiveDelegationInfo.allPoolTotalCapital));
    console.log('Pool commision rates:', passiveDelegationInfo.commissionRates);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const delegators: AsyncIterable<DelegatorInfo> = client.getPassiveDelegators(blockHash);

    console.log('Each staking account and the amount of stake they have:\n');
    for await (const delegatorInfo of delegators) {
        console.log(delegatorInfo.account, delegatorInfo.stake);
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const delegators: AsyncIterable<DelegatorRewardPeriodInfo> = client.getPassiveDelegatorsRewardPeriod(blockHash);

    console.log('Each staking account and the amount of stake they have:\n');
    for await (const delegatorInfo of delegators) {
        console.log(delegatorInfo.account, delegatorInfo.stake);
    }

    const peerInfo: PeerInfo[] = await client.getPeersInfo();

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const delegators: AsyncIterable<DelegatorInfo> = client.getPoolDelegators(BigInt(cli.flags.poolOwner), blockHash);

    console.log('Each staking account and the amount of stake they have:\n');
    for await (const delegatorInfo of delegators) {
        console.log(delegatorInfo.account, delegatorInfo.stake);
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const delegators: AsyncIterable<DelegatorRewardPeriodInfo> = client.getPoolDelegatorsRewardPeriod(
        BigInt(cli.flags.poolOwner),
        blockHash
    );

    console.log('Each staking account and the amount of stake they have:\n');
    for await (const delegatorInfo of delegators) {
        console.log(delegatorInfo.account, delegatorInfo.stake);
    }

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const bakerPool: BakerPoolStatus = await client.getPoolInfo(BigInt(cli.flags.poolOwner), blockHash);

    console.log('Open status:', bakerPool.poolInfo?.openStatus);
    console.log('Baker address:', bakerPool.bakerAddress);
    console.log(
        'CCD provided by the baker to the pool:',
        bakerPool.bakerEquityCapital !== undefined ? CcdAmount.toCcd(bakerPool.bakerEquityCapital) : undefined
    );
    console.log(
        'CCD provided by the delegators to the pool:',
        bakerPool.delegatedCapital !== undefined ? CcdAmount.toCcd(bakerPool.delegatedCapital) : undefined
    );
    console.log('Total capital in CCD of ALL pools:', CcdAmount.toCcd(bakerPool.allPoolTotalCapital));
    console.log('Pool commision rates:', bakerPool.poolInfo?.commissionRates);

    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);
    const tokenomics = await client.getTokenomicsInfo(blockHash);

    // Protocol version 4 expanded the amount of information in the response, so one should check the type to access that.
    // This information includes information about the payday and total amount of funds staked.
    if (tokenomics.version === 1) {
        console.log('Next payday time:', tokenomics.nextPaydayTime);
        console.log('Total staked amount by bakers and delegators', tokenomics.totalStakedCapital);
    }

    // While other information is in both V1 and V0
    console.log('The amount in the baking reward account:', tokenomics.bakingRewardAccount);
    console.log('Total amount in existence:', tokenomics.totalAmount);

    const check = await client.healthCheck();
    if (check.isHealthy) {
        console.log('The node is healthy!');
    } else {
        console.log('The node is not healthy');
        console.log('Message: ' + check.message);
    }

    const contract = ContractAddress.create(cli.flags.contract);
    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);

    const state: HexString = await client.instanceStateLookup(contract, cli.flags.key, blockHash);

    // Handle the optional arguments
    const invoker = cli.flags.invoker ? AccountAddress.fromBase58(cli.flags.invoker) : undefined;
    const amount = cli.flags.amount ? CcdAmount.fromMicroCcd(cli.flags.amount) : undefined;
    const parameter = cli.flags.parameter ? Parameter.fromHexString(cli.flags.parameter) : undefined;
    const energy = cli.flags.energy ? Energy.create(cli.flags.energy) : undefined;

    const contract = ContractAddress.create(cli.flags.contract);
    const context: ContractContext = {
        // Required
        method: ReceiveName.fromString(cli.flags.receive),
        contract,
        // Optional
        invoker,
        amount,
        parameter,
        energy,
    };
    const blockHash = cli.flags.block === undefined ? undefined : BlockHash.fromHexString(cli.flags.block);

    const result = await client.invokeContract(context, blockHash);

    // We can inspect the result
    if (result.tag === 'failure') {
        console.log('Invoke was unsuccesful');
        console.log('The reason the update failed:', result.reason);
    } else if (result.tag === 'success') {
        console.log('Invoke was succesful');

        const returnValue = result.returnValue; // If the invoked method has return value
        if (returnValue) {
            console.log('The return value of the invoked method:', ReturnValue.toHexString(returnValue));
        }

        const events: ContractTraceEvent[] = result.events;
        console.log('A list of effects that the update would have:');
        console.dir(events, { depth: null, colors: true });
    }

    await client.peerConnect(cli.flags.ip, cli.flags.port);
    console.log('Successfully connected to peer');

    await client.peerDisconnect(cli.flags.ip, cli.flags.port);
    console.log('Successfully disconnected from peer');

    const walletFile = readFileSync(cli.flags.walletFile, 'utf8');
    const walletExport = parseWallet(walletFile);
    const sender = AccountAddress.fromBase58(walletExport.value.address);

    const toAddress = AccountAddress.fromBase58(cli.flags.receiver);
    const nextNonce: NextAccountNonce = await client.getNextAccountNonce(sender);

    const header: AccountTransactionHeader = {
        expiry: TransactionExpiry.futureMinutes(60),
        nonce: nextNonce.nonce,
        sender,
    };

    // Include memo if it is given otherwise don't
    let simpleTransfer = undefined;
    if (cli.flags.memo) {
        simpleTransfer = {
            amount: CcdAmount.fromMicroCcd(cli.flags.amount),
            toAddress,
            memo: new DataBlob(Buffer.from(cli.flags.memo, 'hex')),
        };
    } else {
        simpleTransfer = {
            amount: CcdAmount.fromMicroCcd(cli.flags.amount),
            toAddress,
        };
    }

    const accountTransaction: AccountTransaction = {
        header: header,
        payload: simpleTransfer,
        type: AccountTransactionType.Transfer,
    };

    // Sign transaction
    const signer = buildAccountSigner(walletExport);
    const signature: AccountTransactionSignature = await signTransaction(accountTransaction, signer);

    const transactionHash = await client.sendAccountTransaction(accountTransaction, signature);

    const status = await client.waitForTransactionFinalization(transactionHash);
    console.dir(status, { depth: null, colors: true });

    await client.shutdown();
    console.log('Node succesfully shut down');

    await client.unbanPeer(cli.flags.ip);
    console.log('Successfully unbanned peer');