an error occurs with get_nonce rpc method

[sasdecompte]

Hi,
Thank you in advance for all your answers.

To obtain the nonce for each transaction, I use get_nonce rpc method, like this:

axios.post("[http://localhost:5000/get_nonce",{
params: {
address:"60aafa56e838661b90a147d2fe13149ef8e3513a44530c5a7fa37301985ed349"
},
});

the system gives me :
Response { success: true, payload: { nonce: 0} }

const transaction = new Transaction("535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1", "10", "1", {}, 0);

Transaction.sign(transaction, ec.keyFromPrivate("84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"));

axios.post("[http://localhost:5000/sendTransaction",{
params: {
transaction: Transaction.serialize(transaction)
},
});

and when I put this nonce in the transaction, the system says :
LOG [2024-01-09T11:46:42.088Z] Sent one transaction.
ERROR [2024-01-09T11:46:42.103Z] Failed to add one transaction to pool.

when I change 0 by 1, the transaction is completed correctly.
when I check the balance, it's ok :
Response { success: true, payload: { balance: '10' } }

and when I make a second transaction, I use a second time get_nonce rpc method, and the system gives me :
Response { success: true, payload: { nonce: 1 } }

and when I push the transaction with this nonce, the system says :
LOG [2024-01-09T11:59:46.605Z] Sent one transaction.
LOG [2024-01-09T11:59:46.620Z] Added one transaction to pool.

and when I check the balance, I see that the transaction is not completed correctly.
and I find myself stuck, no nonce works anymore.
It looks like there is a gap in the allocation of nonces.
Do you know what this is due to?

As a reminder :
"FIRST_ACCOUNT": "52472d59e3c01bc2cf9496c959d924ce5f469d4e097c395f5605f70633e44a28",

Address n°1, mining the blocks ->
Address : "60aafa56e838661b90a147d2fe13149ef8e3513a44530c5a7fa37301985ed349"
Public key : "04641218a10e698a21ac9eba4e3b29a30a9dd07bbb8d98136b576bbc19fe6f3187195936550cf4ce8d898b9e9687345ab62351df350f17d777e94e9cbaa9092f87"
Private key: "84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"

Address n°2, do nothing, it only receives transactions
Address : "535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1"
Public key : "041ce8d242440c5dc46868eb73abc913c9875ebebcf3152070ae146655bfdeebf082ba329fc4a565040873a2cfe56f46dd045153654b48fb1ee794bec04d2105fd"
Private key: "a497a4a79ca256f5855e4b07d155c2a5f3c44d5d68700e58f7c6fc097efc34e1"

[nguyenphuminh]

Did you try nonce 2? Because you have to add 1 to what the server returns.

Also can you send me the full code of your transactions?

[nguyenphuminh]

Thanks for finding this out! I have pushed a new release to fix this, if there are any further problems, please let me know.

If you want to know why it happened, it's because of an error in the transaction pool. It checks whether a transaction has a nonce higher than all transactions made by the same sender in the pool. Some how I set the default nonce to 0 (in case there are no transactions in the pool), it was supposed to be the current nonce of the sender.

[sasdecompte]

Ok good! this problem is resolved.
But solving that problem created another.

Now when you issue a transaction, as long as this transaction is not validated in a block you cannot issue another one.

For example :
1st transaction: nonce = 1
LOG [2024-01-13T20:11:12.420Z] Sent one transaction.
LOG [2024-01-13T20:11:12.431Z] Added one transaction to pool.

2nd transaction: nonce = 2
LOG [2024-01-13T20:10:59.571Z] Sent one transaction.
ERROR [2024-01-13T20:10:59.577Z] Failed to add one transaction to pool: Transaction is invalid.

You cannot send several transactions in the same block even though you have funds available on your address.

And I have other questions :
in the config.json file, I don't understand what these keys are for :
BLOCK_GAS_LIMIT ?

INITIAL_SUPPLY ?
FIRST_ACCOUNT ?
why deliver all the supply to one address, I don't understand why one address would receive all the supply ?
shouldn't there be only rewards as monetary creation and not an address that would receive all the supply?

config.json
{
"BLOCK_REWARD": "202977000000000000",
"BLOCK_TIME": 30000,
"BLOCK_GAS_LIMIT": "50000000000000",
"INITIAL_SUPPLY": "100000000000000000000000000",
"EMPTY_HASH": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"FIRST_ACCOUNT": "52472d59e3c01bc2cf9496c959d924ce5f469d4e097c395f5605f70633e44a28",
"CONTRACT_FLAG": {
"DEPLOY": 0,
"CALL": 1
}
}

[nguyenphuminh]

Can you send me the code to replicate this error, because when I tried it myself:

Code:

const axios = require('axios');
const EC = require("elliptic").ec;
const ec = new EC("secp256k1");
const Transaction = require("./src/core/transaction");

const getNonce =    axios.post("http://localhost:20297/get_nonce",{
                            params: {
                            address: "60aafa56e838661b90a147d2fe13149ef8e3513a44530c5a7fa37301985ed349"           
                        },
                    })


Promise.all([getNonce])
    .then((results) => {
        const nonce = results[0].data.payload.nonce;
        console.log("New Nonce", nonce)

        // Create 3 new transactions
        const transaction1 = new Transaction("535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1",
                                    "100", 
                                    "1", 
                                    {}, 
                                    nonce + 1);
        Transaction.sign(transaction1, ec.keyFromPrivate("84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"));

        const transaction2 = new Transaction("535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1",
                                    "101", 
                                    "1", 
                                    {}, 
                                    nonce + 2);
        Transaction.sign(transaction2, ec.keyFromPrivate("84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"));

        const transaction3 = new Transaction("535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1",
                                    "102", 
                                    "1", 
                                    {}, 
                                    nonce + 3);
        Transaction.sign(transaction3, ec.keyFromPrivate("84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"));
    
        
        // Send 3 new transactions
        axios.post("http://localhost:20297/sendTransaction",{
            params: {
                transaction: Transaction.serialize(transaction1)
            },
        });

        axios.post("http://localhost:20297/sendTransaction",{
            params: {
                transaction: Transaction.serialize(transaction2)
            },
        });

        axios.post("http://localhost:20297/sendTransaction",{
            params: {
                transaction: Transaction.serialize(transaction3)
            },
        });


        // Get balance after 20 secs
        setTimeout(() => {
            axios.post("http://localhost:20297/get_balance",{
                params: {
                    address: "535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1"
                },
            })
            .then((response) => {
                        console.log(`Response`, response.data);
                    })
                    .catch((error) => {
                        console.error(`2ndError`, error.response.data);
                    });
        }, 20000);
    }
);

It gives me balance 303 which is correct, with no error in the console, and these 3 transactions are all in the same block:

LOG [2024-01-14T01:47:04.650Z] Block #2 mined and synced, state transited.
LOG [2024-01-14T01:47:05.048Z] Sent one transaction.
LOG [2024-01-14T01:47:05.064Z] Sent one transaction.
LOG [2024-01-14T01:47:05.071Z] Sent one transaction.
LOG [2024-01-14T01:47:05.098Z] Added one transaction to pool.
LOG [2024-01-14T01:47:05.102Z] Added one transaction to pool.
LOG [2024-01-14T01:47:05.109Z] Added one transaction to pool.
LOG [2024-01-14T01:47:08.488Z] Block #3 mined and synced, state transited.

About the supply, one address can receive the supply and then sell off through an ICO or something to distribute the coins to others. There are many reasons to why an initial supply is beneficial:

• Immediate allocation which brings more stability at launch. If there is no initial allocation, you need a long time to mine for a stable amount of coins to be minted. Because the amount minted is not that small compared to the current circulating supply, the price might be affected badly as coins are mined until the supply gets big enough.
• If I'm switching to PoS, then an initial amount is needed for stakers, you can not stake if there is no coin to stake.
• This makes it much easier to test with higher balance.

Of course there are downsides to this too, fair distribution is actually pretty hard to do right :/

There is no official JeChain network yet, if you are launching a JeChain-based chain you can change the initial supply to 0 if you don't want that.

BLOCK_GAS_LIMIT is the maximum amount of contract execution gas allowed in a block.

[sasdecompte]

Very well ! now, I understand the various reasons which can lead to wanting to release a quantity of token.
I look forward to see how you're going to integrate PoS, are you considering completely changing the consensus mechanism only to PoS or mixing the two types of consensus PoS and PoW (= Proof of Activity (PoA))?

Regarding BLOCK_GAS_LIMIT, how is this limit determined ?

And regarding the error, I got this error when executing this code 3 times.

code :

const axios = require('axios');
const EC = require("elliptic").ec;
const ec = new EC("secp256k1");
const Transaction = require("../JeChain3000/src/core/transaction");

const getNonce =    axios.post("http://localhost:5000/get_nonce",{
                            params: {
                            address: "60aafa56e838661b90a147d2fe13149ef8e3513a44530c5a7fa37301985ed349"           
                        },
                    })


Promise.all([getNonce])
    .then((results) => {

        let nonce = results[0].data.payload.nonce+1+i;
        console.log("New Nonce", nonce)

        const transaction = new Transaction("535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1",
                                    "50", 
                                    "1", 
                                    {}, 
                                    nonce);
        Transaction.sign(transaction, ec.keyFromPrivate("84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"));
    
        

        axios.post("http://localhost:5000/sendTransaction",{
            params: {
                transaction: Transaction.serialize(transaction)
            },
        });

        setTimeout(() => {
            axios.post("http://localhost:5000/get_balance",{
                params: {
                    address: "535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1"
                },
            })
            .then((response) => {
                        console.log(`Response`, response.data);
                    })
                    .catch((error) => {
                        console.error(`2ndError`, error.response.data);
                    });
        }, 20000);
    }

Which suggests that the current nonce will always be the same until it has been validated in a block.
And to avoid this error, on the client side, you must proceed with an increment and therefore anticipate the number of transactions that you wish to execute, as you did in your code or like this :

code :

const axios = require('axios');
const EC = require("elliptic").ec;
const ec = new EC("secp256k1");
const Transaction = require("../JeChain3000/src/core/transaction");

let amounts = ["100", "101", "102"];
let gas_fees = ["1", "2", "3"];

const number_of_transactions = amounts.length;

for(let i = 0; i < number_of_transactions; i++){
    const amount = amounts[i];
    const gas = gas_fees[i];

    const getNonce =    axios.post("http://localhost:5000/get_nonce",{
                            params: {
                                address: "60aafa56e838661b90a147d2fe13149ef8e3513a44530c5a7fa37301985ed349"           
                            },
                        });


    Promise.all([getNonce])
        .then((results) => {

            let nonce = results[0].data.payload.nonce+1+i;
            console.log("New Nonce", nonce)

            let transaction = new Transaction("535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1",
                                    amount, 
                                       gas, 
                                        {}, 
                                    nonce);

            Transaction.sign(transaction, ec.keyFromPrivate("84f054b3f3183be5dab51d60d34cf6e0783ac9db6671ade83dfbda0f1cc88860"));
            
        

            axios.post("http://localhost:5000/sendTransaction",{
                params: {
                    transaction: Transaction.serialize(transaction)
                },
            });

        });
};

setTimeout(() => {
    axios.post("http://localhost:5000/get_balance",{
        params: {
            address: "535f3a402d563320e153d902bcfe178572128033adc7d293760d4dd78c5c53d1"
        },
    })
    .then((response) => {
                console.log(`Response`, response.data);
            })
            .catch((error) => {
                console.error(`2ndError`, error.response.data);
            });
}, 20000);

[nguyenphuminh]

are you considering completely changing the consensus mechanism only to PoS or mixing the two types of consensus PoS and PoW (= Proof of Activity (PoA))?

I don't know what proof of activity is, but I might mix PoW and PoS similar to how Ethereum does it. They start with PoW for several years and then switch to PoS, so a portion of the circulating supply are distributed fairly to miners. If I start only with PoS, there isn't really a way to prove whether the guy with the initial supply actually distribute fairly to others or not.

Regarding BLOCK_GAS_LIMIT, how is this limit determined?

Currently it is kind of mindlessly configured, and gas in the current contract runtime env is also mindlessly configured as well, I am planning to port it to a custom EVM that I am making with configurations similar to Ethereum so no prob on that.

About how this limit is actually determined in production:

• How much cost would you want a node runner to spend for a node in your blockchain network? A limit only means the maximum amount of execution a node must be able to do in a period of time. So if we are looking at Bitcoin, Chia, Ethereum, etc, they want the average person to be able to run a node, so they set the limit low which makes them decentralized because people probably have a computer that can already run a node. But if we are talking about centralized chains like Solana, BSC, Fantom, etc, they want higher scalability (bigger limit means you can compute more), so they increase the limit so high that only rich people can run a node.
• When you have decided what is the desired node hardware requirements, try to do benchmarks with each opcode of your VM to see how much each opcode costs, compare them with each other to get a general computational cost unit, then see how much computational unit can a computer with such hardware requirement can do, then you get the limit.

About the transaction code, get nonce only returning the latest finalized nonce is not a bug.