Merge pull request #2720 from aeternity/PT-lima-claim-fee

Pt lima claim fee

apps/aechannel/test/aesc_txs_SUITE.erl

@@ -5235,7 +5235,12 @@ register_name(Name, Pointers0) ->
             fun(#{state := S, name_owner := NameOwner, height := Height0} = Props) ->
                 PrivKey = aesc_test_utils:priv_key(NameOwner, S),
                 Delta = aec_governance:name_claim_preclaim_delta(),
-                TxSpec = aens_test_utils:claim_tx_spec(NameOwner, Name, NameSalt, S),
+                NameFee =
+                        case aec_hard_forks:protocol_effective_at_height(Height0) >= ?LIMA_PROTOCOL_VSN of
+                            true -> 3400000;
+                            false -> prelima
+                        end,
+                TxSpec = aens_test_utils:claim_tx_spec(NameOwner, Name, NameSalt, NameFee, S),
                 {ok, Tx} = aens_claim_tx:new(TxSpec),
                 SignedTx = aec_test_utils:sign_tx(Tx, PrivKey),
                 apply_on_trees_(Props#{height := Height0 + Delta}, SignedTx, S, positive)

apps/aecontract/test/aecontract_SUITE.erl

@@ -3535,8 +3535,8 @@ sophia_signatures_oracles(_Cfg) ->
 sophia_signatures_aens(Cfg) ->
     state(aect_test_utils:new_state()),
     %% AENS transactions from contract - using 3rd party account
-    Acc             = ?call(new_account, 20000000 * aec_test_utils:min_gas_price()),
-    NameAcc         = ?call(new_account, 20000000 * aec_test_utils:min_gas_price()),
+    Acc             = ?call(new_account, 30000000 * aec_test_utils:min_gas_price()),
+    NameAcc         = ?call(new_account, 30000000 * aec_test_utils:min_gas_price()),
     Ct              = ?call(create_contract, NameAcc, aens, {}, #{ amount => 100000 }),
     Name1           = aens_test_utils:fullname(<<"bla">>),
     Salt1           = rand:uniform(10000),
@@ -5060,9 +5060,12 @@ aens_preclaim(PubKey, Name, Options, S) ->
     {Salt, S1}.
 
 aens_claim(PubKey, Name, Salt, S) ->
-    aens_claim(PubKey, Name, Salt, #{}, S).
+    aens_claim(PubKey, Name, Salt, prelima, #{}, S).
 
-aens_claim(PubKey, Name, Salt, Options, S) ->
+aens_claim(PubKey, Name, Salt, NameFee, S) ->
+    aens_claim(PubKey, Name, Salt, NameFee, #{}, S).
+
+aens_claim(PubKey, Name, Salt, NameFee, Options, S) ->
     Nonce  = aect_test_utils:next_nonce(PubKey, S),
     Height = maps:get(height, Options, 2),
     Fee    = maps:get(fee, Options, 50000 * aec_test_utils:min_gas_price()),
@@ -5073,6 +5076,7 @@ aens_claim(PubKey, Name, Salt, Options, S) ->
                                     nonce      => Nonce,
                                     name       => Name,
                                     name_salt  => Salt,
+                                    name_fee   => NameFee,
                                     fee        => Fee,
                                     ttl        => TTL }),
     PrivKey  = aect_test_utils:priv_key(PubKey, S),
@@ -5118,7 +5122,7 @@ aens_update(PubKey, NameHash, Pointers, Options, S) ->
     {ok, S1} = sign_and_apply_transaction(Tx, PrivKey, S, Height),
     {ok, S1}.
 
-sophia_aens_resolve(_Cfg) ->
+sophia_aens_resolve(Cfg) ->
     state(aect_test_utils:new_state()),
     Acc      = ?call(new_account, 20000000 * aec_test_utils:min_gas_price()),
     Ct       = ?call(create_contract, Acc, aens, {}, #{ amount => 100000 }),
@@ -5133,7 +5137,12 @@ sophia_aens_resolve(_Cfg) ->
                ],
 
     Salt  = ?call(aens_preclaim, Acc, Name),
-    Hash  = ?call(aens_claim, Acc, Name, Salt),
+    NameFee = 3400000,
+    Hash  = case ?config(vm_version, Cfg) of
+                  VMVersion when ?IS_AEVM_SOPHIA(VMVersion), VMVersion >= ?VM_AEVM_SOPHIA_4 -> ?call(aens_claim, Acc, Name, Salt, NameFee);
+                  VMVersion when ?IS_AEVM_SOPHIA(VMVersion), VMVersion < ?VM_AEVM_SOPHIA_4 -> ?call(aens_claim, Acc, Name, Salt);
+                  VMVersion when ?IS_FATE_SOPHIA(VMVersion) -> ?call(aens_claim, Acc, Name, Salt, NameFee)
+            end,
     ok    = ?call(aens_update, Acc, Hash, Pointers),
 
     {some, Account} = ?call(call_contract, Acc, Ct, resolve_account, {option, word},   {Name, <<"account_pubkey">>}),
@@ -5173,8 +5182,8 @@ sophia_aens_resolve(_Cfg) ->
 sophia_aens_transactions(Cfg) ->
     %% AENS transactions from contract
     state(aect_test_utils:new_state()),
-    Acc      = ?call(new_account, 20000000 * aec_test_utils:min_gas_price()),
-    Ct       = ?call(create_contract, Acc, aens, {}, #{ amount => 100000 }),
+    Acc      = ?call(new_account, 40000000 * aec_test_utils:min_gas_price()),
+    Ct       = ?call(create_contract, Acc, aens, {}, #{ amount => 20000000 * aec_test_utils:min_gas_price() }),
 
     APubkey  = 1,
     OPubkey  = 2,

apps/aecore/src/aec_governance.erl

@@ -14,6 +14,7 @@
          minimum_gas_price/1,
          name_preclaim_expiration/0,
          name_claim_locked_fee/0,
+         name_claim_fee/2,
          name_claim_max_expiration/0,
          name_protection_period/0,
          name_claim_preclaim_delta/0,
@@ -245,6 +246,12 @@ name_protection_period() ->
 name_claim_preclaim_delta() ->
     1.
 
+-spec name_claim_fee(binary(), non_neg_integer()) -> non_neg_integer().
+name_claim_fee(Name, Protocol) when Protocol >= ?LIMA_PROTOCOL_VSN ->
+    1000 - size(Name);  %% here we can make a variable fee depending on name
+name_claim_fee(_Name, _Protocol) ->
+    0.
+
 -spec name_registrars(aec_hard_forks:protocol_vsn()) -> list(binary()).
 name_registrars(Protocol) when Protocol >= ?LIMA_PROTOCOL_VSN ->
     non_test_registrars();

apps/aecore/src/aec_vm_chain.erl

@@ -38,7 +38,7 @@
           aens_resolve/4,
           aens_preclaim_tx/3,
           aens_preclaim/3,
-          aens_claim_tx/4,
+          aens_claim_tx/5,
           aens_claim/3,
           aens_transfer_tx/4,
           aens_transfer/3,
@@ -583,18 +583,19 @@ aens_preclaim_(Tx, Signature, State) ->
         Err = {error, _} -> Err
     end.
 
--spec aens_claim_tx(aec_keys:pubkey(), binary(), integer(), chain_state()) ->
+-spec aens_claim_tx(aec_keys:pubkey(), binary(), integer(), integer() | prelima, chain_state()) ->
     {ok, aetx:tx()} | {error, term()}.
-aens_claim_tx(Addr, Name, Salt, State) ->
-    on_chain_only(State, fun() -> aens_claim_tx_(Addr, Name, Salt, State) end).
+aens_claim_tx(Addr, Name, Salt, NameFee, State) ->
+    on_chain_only(State, fun() -> aens_claim_tx_(Addr, Name, Salt, NameFee, State) end).
 
-aens_claim_tx_(Addr, Name, Salt, State) ->
+aens_claim_tx_(Addr, Name, Salt, NameFee, State) ->
     Nonce = next_nonce(Addr, State),
     Spec =
         #{ account_id => aeser_id:create(account, Addr),
            nonce      => Nonce,
            name       => Name,
            name_salt  => Salt,
+           name_fee   => NameFee,
            fee        => 0
          },
     aens_claim_tx:new(Spec).

apps/aefate/src/aefa_chain_api.erl

@@ -42,7 +42,7 @@
         , is_oracle/2
         , is_contract/2
         , is_payable/2
-        , aens_claim/4
+        , aens_claim/5
         , aens_preclaim/3
         , aens_resolve/3
         , aens_revoke/3
@@ -634,12 +634,11 @@ aens_resolve_from_pstate(NameString, Key, PState) ->
 aens_preclaim(Pubkey, Hash, #state{} = S) when ?IS_ONCHAIN(S) ->
     eval_primops([aeprimop:name_preclaim_op(Pubkey, Hash, 0)], S).
 
-aens_claim(Pubkey, NameBin, SaltInt, #state{} = S) when ?IS_ONCHAIN(S) ->
+aens_claim(Pubkey, NameBin, SaltInt, NameFee, #state{} = S) when ?IS_ONCHAIN(S) ->
     PreclaimDelta = aec_governance:name_claim_preclaim_delta(),
     DeltaTTL = aec_governance:name_claim_max_expiration(),
-    LockedFee = aec_governance:name_claim_locked_fee(),
-    Instructions = [ aeprimop:lock_amount_op(Pubkey, LockedFee)
-                   , aeprimop:name_claim_op(Pubkey, NameBin, SaltInt,
+    Instructions = [ aeprimop:lock_amount_op(Pubkey, NameFee)
+                   , aeprimop:name_claim_op(Pubkey, NameBin, SaltInt, NameFee,
                                             DeltaTTL, PreclaimDelta)
                    ],
     eval_primops(Instructions, S, size_gas([NameBin])).

apps/aefate/src/aefa_fate_op.erl

@@ -114,7 +114,7 @@
         , is_payable/3
         , aens_resolve/5
         , aens_preclaim/4
-        , aens_claim/5
+        , aens_claim/6
         , aens_update/1
         , aens_transfer/5
         , aens_revoke/4
@@ -1172,9 +1172,9 @@ aens_preclaim(Arg0, Arg1, Arg2, EngineState) ->
     end.
 
 
-aens_claim(Arg0, Arg1, Arg2, Arg3, EngineState) ->
-    {[Signature, Account, NameString, Salt], ES1} =
-        get_op_args([Arg0, Arg1, Arg2, Arg3], EngineState),
+aens_claim(Arg0, Arg1, Arg2, Arg3, Arg4, EngineState) ->
+    {[Signature, Account, NameString, Salt, NameFee], ES1} =
+        get_op_args([Arg0, Arg1, Arg2, Arg3, Arg4], EngineState),
     if
         not ?IS_FATE_BYTES(64, Signature) ->
             aefa_fate:abort({value_does_not_match_type, Signature, bytes64}, ES1);
@@ -1186,6 +1186,10 @@ aens_claim(Arg0, Arg1, Arg2, Arg3, EngineState) ->
             aefa_fate:abort({value_does_not_match_type, Salt, integer}, ES1);
         not ?FATE_INTEGER_VALUE(Salt) >= 0 ->
             aefa_fate:abort({primop_error, aens_claim, negative_salt}, ES1);
+        not ?IS_FATE_INTEGER(NameFee) ->
+            aefa_fate:abort({value_does_not_match_type, NameFee, integer}, ES1);
+        not ?FATE_INTEGER_VALUE(NameFee) >= 0 ->
+            aefa_fate:abort({primop_error, aens_claim, negative_fee}, ES1);
         true ->
             ok
     end,
@@ -1198,8 +1202,9 @@ aens_claim(Arg0, Arg1, Arg2, Arg3, EngineState) ->
         {ok, HashBin} ->
             ES2 = check_delegation_signature(aens_claim, {Pubkey, HashBin}, SignBin, ES1),
             SaltInt = ?FATE_INTEGER_VALUE(Salt),
+            NameFeeInt = ?FATE_INTEGER_VALUE(NameFee),
             API = aefa_engine_state:chain_api(ES2),
-            case aefa_chain_api:aens_claim(Pubkey, NameBin, SaltInt, API) of
+            case aefa_chain_api:aens_claim(Pubkey, NameBin, SaltInt, NameFeeInt, API) of
                 {ok, DynamicGas, API1} ->
                     ES3 = spend_gas(DynamicGas, ES2),
                     aefa_engine_state:set_chain_api(API1, ES3);
@@ -1741,4 +1746,3 @@ pow(A, B) ->
 pow(_, 0, R)                   -> R;
 pow(A, B, R) when B rem 2 == 0 -> pow(A * A, B bsr 1, R);
 pow(A, B, R)                   -> pow(A * A, B bsr 1, R * A).
-

apps/aehttp/priv/swagger.json

@@ -2660,6 +2660,9 @@
         "name_salt" : {
           "$ref" : "#/definitions/UInt"
         },
+        "name_fee" : {
+          "$ref" : "#/definitions/UInt"
+        },
         "fee" : {
           "$ref" : "#/definitions/UInt"
         },

apps/aehttp/src/aehttp_dispatch_int.erl

@@ -149,7 +149,7 @@ handle_request_('PostNameUpdate', #{'NameUpdateTx' := Req}, _Context) ->
 handle_request_('PostNameClaim', #{'NameClaimTx' := Req}, _Context) ->
     ParseFuns = [parse_map_to_atom_keys(),
                  read_required_params([account_id, name, name_salt, fee]),
-                 read_optional_params([{ttl, ttl, '$no_value'}]),
+                 read_optional_params([{ttl, ttl, '$no_value'}, {name_fee, name_fee, prelima}]),
                  api_decode([{account_id, account_id, {id_hash, [account_pubkey]}},
                                 {name, name, name}]),
                  get_nonce_from_account_id(account_id),

apps/aehttp/test/aehttp_integration_SUITE.erl

@@ -2315,13 +2315,24 @@ nameservice_transaction_claim(MinerAddress, MinerPubkey, Height) ->
     ok = wait_for_tx_hash_on_chain(PreclaimTxHash),
     {ok, []} = rpc(aec_tx_pool, peek, [infinity]),
 
-    Encoded = #{account_id => MinerAddress,
-                name => aeser_api_encoder:encode(name, Name),
-                name_salt => Salt,
-                fee => 100000 * aec_test_utils:min_gas_price()},
+    Encoded =
+        case aec_hard_forks:protocol_effective_at_height(Height) >= ?LIMA_PROTOCOL_VSN of
+            true ->
+                #{account_id => MinerAddress,
+                  name => aeser_api_encoder:encode(name, Name),
+                  name_salt => Salt,
+                  name_fee => 340000,
+                  fee => 100000 * aec_test_utils:min_gas_price()};
+            false ->
+                #{account_id => MinerAddress,
+                  name => aeser_api_encoder:encode(name, Name),
+                  name_salt => Salt,
+                  fee => 100000 * aec_test_utils:min_gas_price()}
+        end,
     Decoded = maps:merge(Encoded,
                         #{account_id => aeser_id:create(account, MinerPubkey),
                           name => Name}),
+    ct:pal("Tx ~p and encoded ~p", [Decoded, Encoded]),
     unsigned_tx_positive_test(Decoded, Encoded,
                                fun get_name_claim/1,
                                fun aens_claim_tx:new/1, MinerPubkey),
@@ -2713,6 +2724,8 @@ unsigned_tx_positive_test(Data, Params0, HTTPCallFun, NewFun, Pubkey,
             {ok, ExpectedTx} = NewFun(maps:put(nonce, Nonce, Data)),
             {ok, 200, #{<<"tx">> := ActualTx}} = HTTPCallFun(P),
             {ok, SerializedTx} = aeser_api_encoder:safe_decode(transaction, ActualTx),
+                ct:pal("SerializedTx: ~p", [SerializedTx]),
+
             Tx = aetx:deserialize_from_binary(SerializedTx),
             ct:log("Expected ~p~nActual ~p", [ExpectedTx, Tx]),
             ExpectedTx = Tx,
@@ -3058,10 +3071,20 @@ naming_system_manage_name(_Config) ->
     ?assertEqual(Balance1, Balance - Fee),
 
     %% Submit name claim tx and check it is in mempool
-    ClaimData = #{account_id => PubKeyEnc,
+    {ClaimData, NameFee} =
+        case aec_hard_forks:protocol_effective_at_height(Height) >= ?LIMA_PROTOCOL_VSN of
+            true ->
+                {#{account_id => PubKeyEnc,
                   name       => aeser_api_encoder:encode(name, Name),
                   name_salt  => NameSalt,
-                  fee        => Fee},
+                  name_fee   => 340000,
+                  fee        => Fee}, 340000};
+            false ->
+                {#{account_id => PubKeyEnc,
+                  name       => aeser_api_encoder:encode(name, Name),
+                  name_salt  => NameSalt,
+                  fee        => Fee},  rpc(aec_governance, name_claim_locked_fee, [])}
+        end,
     {ok, 200, #{<<"tx">> := ClaimTxEnc}} = get_name_claim(ClaimData),
     ClaimTxHash = sign_and_post_tx(ClaimTxEnc, PrivKey),
 
@@ -3071,10 +3094,9 @@ naming_system_manage_name(_Config) ->
 
     %% Check tx fee taken from account, claim fee locked,
     %% then mine reward and fee added to account
-    ClaimLockedFee = rpc(aec_governance, name_claim_locked_fee, []),
     {ok, 200, #{<<"balance">> := Balance2}} = get_accounts_by_pubkey_sut(PubKeyEnc),
     {ok, 200, #{<<"height">> := Height3}} = get_key_blocks_current_sut(),
-    ?assertEqual(Balance2, Balance1 - Fee - ClaimLockedFee),
+    ?assertEqual(Balance2, Balance1 - Fee - NameFee),
 
     %% Check that name entry is present
     EncodedNHash = aeser_api_encoder:encode(name, NHash),

apps/aehttp/test/aehttp_sc_SUITE.erl

@@ -1674,7 +1674,13 @@ sc_ws_nameservice_contract_(Owner, GetVolley, CreateContract, ConnPid1, ConnPid2
         end,
 
     Test(Name, <<"oracle">>, false),
-    register_name(NamePubkey, NamePrivkey, Name,
+    NameFee =
+        case aect_test_utils:latest_protocol_version() >= ?LIMA_PROTOCOL_VSN of
+            true -> 3400000;
+            false -> prelima
+        end,
+
+    register_name(NamePubkey, NamePrivkey, Name, NameFee,
                   [{<<"account_pubkey">>, aeser_id:create(account, <<1:256>>)},
                    {<<"oracle">>, aeser_id:create(oracle, <<2:256>>)},
                    {<<"unexpected_key">>, aeser_id:create(account, <<3:256>>)}]),
@@ -1852,7 +1858,12 @@ sc_ws_remote_call_contract_refering_onchain_data_(Owner, GetVolley, CreateContra
     % registering the name on-chain
     {NamePubkey, NamePrivkey} = ?CAROL,
     ok = initialize_account(2000000 * aec_test_utils:min_gas_price(), ?CAROL),
-    register_name(NamePubkey, NamePrivkey, Name,
+    NameFee =
+        case aect_test_utils:latest_protocol_version() >= ?LIMA_PROTOCOL_VSN of
+            true -> 3400000;
+            false -> prelima
+        end,
+    register_name(NamePubkey, NamePrivkey, Name, NameFee,
                   [{<<"account_pubkey">>, aeser_id:create(account, <<1:256>>)}]),
 
     % now the name is on-chain, both must return true:
@@ -1907,10 +1918,10 @@ sign_post_mine(Tx, Privkey) ->
     ok = post_tx(TxHash, EncodedSerializedSignedTx),
     ok = wait_for_tx_hash_on_chain(TxHash).
 
-register_name(Owner, OwnerPrivKey, Name, Pointers) ->
+register_name(Owner, OwnerPrivKey, Name, NameFee, Pointers) ->
     Salt = rand:uniform(10000),
     preclaim_name(Owner, OwnerPrivKey, Name, Salt),
-    claim_name(Owner, OwnerPrivKey, Name, Salt),
+    claim_name(Owner, OwnerPrivKey, Name, Salt, NameFee),
     update_pointers(Owner, OwnerPrivKey, Name, Pointers),
     ok.
 
@@ -1923,12 +1934,12 @@ preclaim_name(Owner, OwnerPrivKey, Name, Salt) ->
     sign_post_mine(Tx, OwnerPrivKey),
     ok.
 
-claim_name(Owner, OwnerPrivKey, Name, Salt) ->
+claim_name(Owner, OwnerPrivKey, Name, Salt, NameFee) ->
     Delta = aec_governance:name_claim_preclaim_delta(),
     Node = aecore_suite_utils:node_name(?NODE),
     aecore_suite_utils:mine_key_blocks(Node, Delta),
     {ok, Nonce} = rpc(aec_next_nonce, pick_for_account, [Owner]),
-    TxSpec = aens_test_utils:claim_tx_spec(Owner, Name, Salt,  #{nonce => Nonce},#{}),
+    TxSpec = aens_test_utils:claim_tx_spec(Owner, Name, Salt, NameFee, #{nonce => Nonce}, #{}),
     {ok, Tx} = aens_claim_tx:new(TxSpec),
     sign_post_mine(Tx, OwnerPrivKey),
     ok.