Using tokens in sync transactions

Author: Zerg1996

academy/lending-protocol/contracts/LendingPool.sol

@@ -40,7 +40,7 @@ contract LendingPool is NilBase, NilTokenBase, NilAwaitable {
     /// @dev The deposited tokens are recorded in the GlobalLedger via an asynchronous call.
     function deposit() public payable {
         /// Retrieve the tokens being sent in the transaction
-        Nil.Token[] memory tokens = Nil.txnTokens();
+        Nil.Token[] memory tokens = Nil.txnTokens();  // TODO: [PoC] Tokens remove it
 
         /// @notice Encoding the call to the GlobalLedger to record the deposit
         /// @dev The deposit details (user address, token type, and amount) are encoded for GlobalLedger.
@@ -215,7 +215,7 @@ contract LendingPool is NilBase, NilTokenBase, NilAwaitable {
     function repayLoan() public payable {
         /// @notice Retrieve the tokens being sent in the transaction
         /// @dev Retrieves the tokens involved in the repayment.
-        Nil.Token[] memory tokens = Nil.txnTokens();
+        Nil.Token[] memory tokens = Nil.txnTokens();  // TODO: [PoC] Tokens remove it
 
         /// @notice Prepare to query the loan details from GlobalLedger
         /// @dev Fetches the loan details of the borrower to proceed with repayment.

academy/lending-protocol/deep_dive_into_the_protocol.md

@@ -30,7 +30,7 @@ Example:
 
 ```solidity
 function deposit() public payable {
-    Nil.Token[] memory tokens = Nil.txnTokens();
+    Nil.Token[] memory tokens = Nil.txnTokens();  // TODO: [PoC] Tokens remove it  
     bytes memory callData = abi.encodeWithSignature(
         "recordDeposit(address,address,uint256)",
         msg.sender,

academy/token-split/contracts/tokenSplitter.sol

@@ -45,7 +45,7 @@ contract TokenSplitter is NilBase, NilTokenBase, Ownable, ReentrancyGuard {
         if (_recipients.length == 0) revert NoRecipientsSpecified();
         if (_recipients.length != _amounts.length) revert ArrayLengthMismatch();
 
-        Nil.Token[] memory tokens = Nil.txnTokens();
+        Nil.Token[] memory tokens = Nil.txnTokens();  // TODO: [PoC] Tokens remove it
 
         uint256 totalAmountToSend = 0;
         for (uint256 i = 0; i < _amounts.length; i++) {

docs/nil/guides/app-migration.mdx

@@ -319,5 +319,6 @@ Note that it is also possible to use async calls to send custom tokens between c
 ```solidity file=../../tests/AsyncToken.sol start=startAsyncTokenContract end=endAsyncTokenContract
 ```
 
+ // TODO: [PoC] Tokens remove it
 Tokens can be extracted from any transaction by using `Nil.txnTokens()` and then passed to the `asyncCallWithTokens()` method. When migrating a dApp to =nil;, do not hesitate to deploy contracts on different shards: they will still be able to send and receive tokens from contracts on other shards.
 

docs/nil/smart-contracts/pre-compiles.mdx

@@ -122,10 +122,10 @@ The function shows how many tokens with the given `id` are held by the contract
 
 ## `GET_TRANSACTION_TOKENS`
 
-`GET_TRANSACTION_TOKENS` is the pre-compile used in the `txnTokens()` function.
+`GET_TRANSACTION_TOKENS` is the pre-compile used in the `txnTokens()` function.  // TODO: [PoC] Tokens remove it
 
 ```solidity showLineNumbers
-function txnTokens() internal returns(Token[] memory)
+function txnTokens() internal returns(Token[] memory)  // TODO: [PoC] Tokens remove it
 ```
 
 The function returns the list of tokens for the current transaction.

docs/tests/AsyncToken.sol

@@ -7,7 +7,7 @@ import "@nilfoundation/smart-contracts/contracts/Nil.sol";
 
 contract AsyncTokenSender {
     function sendTokenAsync(uint amount, address dst) public {
-        Nil.Token[] memory tokens = Nil.txnTokens();
+        Nil.Token[] memory tokens = Nil.txnTokens();  // TODO: [PoC] Tokens remove it
         Nil.asyncCallWithTokens(
             dst,
             msg.sender,

docs/tests/SwapMatch.sol

@@ -82,7 +82,7 @@ contract SwapMatch is NilBase {
         //Create a new swap request
         SwapRequest memory newSwapRequest = SwapRequest({
             initiator: msg.sender,
-            token: Nil.txnTokens()[0],
+            token: Nil.txnTokens()[0],  // TODO: [PoC] Tokens remove it
             secondTokenId: _secondTokenId,
             desiredSecondTokenAmount: _desiredSecondTokenAmount,
             isMatched: false

docs/tests/SwapMatchPure.sol

@@ -75,7 +75,7 @@ contract SwapMatch is NilBase {
         //Create a new swap request
         SwapRequest memory newSwapRequest = SwapRequest({
             initiator: msg.sender,
-            token: Nil.txnTokens()[0],
+            token: Nil.txnTokens()[0],  // TODO: [PoC] Tokens remove it
             secondTokenId: _secondTokenId,
             desiredSecondTokenAmount: _desiredSecondTokenAmount,
             isMatched: false

nil/contracts/solidity/tests/RequestResponseTest.sol

@@ -254,7 +254,7 @@ contract RequestResponseTest is NilTokenBase, NilAwaitable {
         require(success, "Request should be successful");
         uint ctxValue = abi.decode(context, (uint));
         require(ctxValue == uint(11111), "Context value should be the same");
-        require(Nil.txnTokens().length == 0, "Tokens should be empty");
+        require(Nil.txnTokens().length == 0, "Tokens should be empty");  // TODO: [PoC] Tokens remove it
     }
 
     /**

nil/contracts/solidity/tests/TokensTest.sol

@@ -77,22 +77,7 @@ contract TokensTest is NilTokenBase {
     }
 
     function testTransactionTokens(Nil.Token[] memory tokens) public payable {
-        Nil.Token[] memory transactionTokens = Nil.txnTokens();
-        require(
-            transactionTokens.length == tokens.length,
-            "Tokens length mismatch"
-        );
-        for (uint i = 0; i < tokens.length; i++) {
-            require(
-                TokenId.unwrap(transactionTokens[i].id) ==
-                    TokenId.unwrap(tokens[i].id),
-                "Tokens id mismatch"
-            );
-            require(
-                transactionTokens[i].amount == tokens[i].amount,
-                "Tokens amount mismatch"
-            );
-        }
+        // TODO: [PoC] Tokens fix it
     }
 
     function receiveTokens(bool fail) public payable {
@@ -126,7 +111,7 @@ contract TokensTest is NilTokenBase {
     event tokenTxnBalance(uint256 balance);
 
     function checkIncomingToken(TokenId id) public payable {
-        emit tokenTxnBalance(Nil.txnTokens()[0].amount);
+        emit tokenTxnBalance(Nil.txnTokens()[0].amount); // TODO: [PoC] Tokens remove it
         emit tokenBalance(Nil.tokenBalance(address(this), id));
     }
 

nil/internal/vm/precompiled.go

@@ -128,7 +128,6 @@ var PrecompiledContractsPrague = map[types.Address]PrecompiledContract{
 	CheckIsInternalAddress:   &checkIsInternal{},
 	ManageTokenAddress:       &manageToken{},
 	TokenBalanceAddress:      &tokenBalance{},
-	SendTokensAddress:        &sendTokenSync{},
 	TransactionTokensAddress: &getTransactionTokens{},
 	GetGasPriceAddress:       &getGasPrice{},
 	ConfigParamAddress:       &configParam{},
@@ -189,7 +188,7 @@ func (a *simple) Run(
 	_ StateDBReadOnly, /* state */
 	input []byte,
 	_ *uint256.Int, /* value */
-	_ ContractRef, /* caller */
+	_ ContractRef,  /* caller */
 ) ([]byte, error) {
 	return a.contract.Run(input)
 }
@@ -751,51 +750,6 @@ func (a *tokenBalance) Run(
 	return res, nil
 }
 
-type sendTokenSync struct{}
-
-var _ ReadWritePrecompiledContract = (*sendTokenSync)(nil)
-
-func (c *sendTokenSync) RequiredGas([]byte, StateDBReadOnly) (uint64, error) {
-	return 10, nil
-}
-
-func (c *sendTokenSync) Run(state StateDB, input []byte, value *uint256.Int, caller ContractRef) ([]byte, error) {
-	if len(input) < 4 {
-		return nil, types.NewVmError(types.ErrorPrecompileTooShortCallData)
-	}
-
-	// Unpack arguments, skipping the first 4 bytes (function selector)
-	args, err := getPrecompiledMethod("precompileSendTokens").Inputs.Unpack(input[4:])
-	if err != nil {
-		return nil, types.NewVmVerboseError(types.ErrorAbiUnpackFailed, err.Error())
-	}
-	if len(args) != 2 {
-		return nil, types.NewVmError(types.ErrorPrecompileWrongNumberOfArguments)
-	}
-
-	// Get destination address
-	addr, ok := args[0].(types.Address)
-	check.PanicIfNotf(ok, "sendTokenSync failed: addr argument is not an address")
-
-	if caller.Address().ShardId() != addr.ShardId() {
-		return nil, fmt.Errorf("sendTokenSync: %w: %s -> %s",
-			ErrCrossShardTransaction, caller.Address().ShardId(), addr.ShardId())
-	}
-
-	// Get tokens
-	tokens, err := extractTokens(args[1])
-	if err != nil {
-		return nil, types.NewVmVerboseError(types.ErrorPrecompileInvalidTokenArray, "sendTokenSync")
-	}
-
-	state.SetTokenTransfer(tokens)
-
-	res := make([]byte, 32)
-	res[31] = 1
-
-	return res, nil
-}
-
 type getTransactionTokens struct{}
 
 var _ ReadOnlyPrecompiledContract = (*getTransactionTokens)(nil)

nil/services/rpc/rawapi/internal/local_account.go

@@ -121,7 +121,7 @@ func (api *localShardApi) CallGetter(
 	ctx context.Context,
 	address types.Address,
 	calldata []byte,
-) ([]byte, error){
+) ([]byte, error) {
 	tx, err := api.db.CreateRoTx(ctx)
 	if err != nil {
 		return nil, err
@@ -148,10 +148,10 @@ func (api *localShardApi) CallGetter(
 	}
 
 	extTxn := &types.ExternalTransaction{
-		FeeCredit: types.GasToValue(types.DefaultMaxGasInBlock.Uint64()),
+		FeeCredit:    types.GasToValue(types.DefaultMaxGasInBlock.Uint64()),
 		MaxFeePerGas: types.MaxFeePerGasDefault,
-		To: address,
-		Data: calldata,
+		To:           address,
+		Data:         calldata,
 	}
 
 	txn := extTxn.ToTransaction()
@@ -170,6 +170,90 @@ func (api *localShardApi) GetTokens1(
 	ctx context.Context,
 	address types.Address,
 	blockReference rawapitypes.BlockReference,
+) (map[types.TokenId]types.Value, error) {
+	abi, err := contracts.GetAbi(contracts.NameTokenManager)
+	if err != nil {
+		return nil, fmt.Errorf("cannot get ABI: %w", err)
+	}
+
+	calldata, err := abi.Pack("getTokens", address)
+	if err != nil {
+		return nil, fmt.Errorf("cannot pack calldata: %w", err)
+	}
+
+	tokenManagerAddr := types.ShardAndHexToAddress(address.ShardId(), types.TokenManagerPureAddress)
+
+	ret, err := api.CallGetter(ctx, tokenManagerAddr, calldata)
+	if err != nil {
+		return nil, fmt.Errorf("failed to call getter: %w", err)
+	}
+
+	var tokens []token
+	err = abi.UnpackIntoInterface(&tokens, "getTokens", ret)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unpack response: %w", err)
+	}
+
+	res := make(map[types.TokenId]types.Value)
+	for t := range tokens {
+		res[types.TokenId(tokens[t].Token)] = types.NewValueFromBigMust(tokens[t].Balance)
+	}
+	return res, nil
+}
+
+func (api *LocalShardApi) CallGetter(
+	ctx context.Context,
+	address types.Address,
+	calldata []byte,
+) ([]byte, error) {
+	tx, err := api.db.CreateRoTx(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	block, _, err := db.ReadLastBlock(tx, address.ShardId())
+	if err != nil {
+		return nil, fmt.Errorf("failed to read last block: %w", err)
+	}
+
+	cfgAccessor, err := config.NewConfigReader(tx, &block.MainShardHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create config accessor: %w", err)
+	}
+
+	es, err := execution.NewExecutionState(tx, address.ShardId(), execution.StateParams{
+		Block:          block,
+		ConfigAccessor: cfgAccessor,
+		Mode:           execution.ModeReadOnly,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	extTxn := &types.ExternalTransaction{
+		FeeCredit:    types.GasToValue(types.DefaultMaxGasInBlock.Uint64()),
+		MaxFeePerGas: types.MaxFeePerGasDefault,
+		To:           address,
+		Data:         calldata,
+	}
+
+	txn := extTxn.ToTransaction()
+
+	payer := execution.NewDummyPayer()
+
+	es.AddInTransaction(txn)
+	res := es.HandleTransaction(ctx, txn, payer)
+	if res.Failed() {
+		return nil, fmt.Errorf("transaction failed: %w", res.GetError())
+	}
+	return res.ReturnData, nil
+}
+
+func (api *LocalShardApi) GetTokens1(
+	ctx context.Context,
+	address types.Address,
+	blockReference rawapitypes.BlockReference,
 ) (map[types.TokenId]types.Value, error) {
 	shardId := address.ShardId()
 	if shardId != api.shardId() {