Class ConcordiumGRPCClient

    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:',
        CcdAmount.toCcd(bakerPool.bakerEquityCapital)
    );
    console.log(
        'CCD provided by the delegators to the pool:',
        CcdAmount.toCcd(bakerPool.delegatedCapital)
    );
    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 });