Merge pull request casper-network#5160 from EdHastingsCasperAssociation/native-transfer-deploy-entry-point-name-fix

[BUGFIX] Deploy native transfer entry point name resolution

Author: darthsiroftardis

node/src/components/contract_runtime/operations.rs

@@ -553,6 +553,11 @@ pub fn execute_finalized_block(
                             .with_added_consumed(gas_limit)
                             .with_burn_result(burn_result)
                             .map_err(|_| BlockExecutionError::RootNotFound(state_root_hash))?;
+                    } else {
+                        artifact_builder.with_error_message(format!(
+                            "Attempt to call unsupported native mint entrypoint: {}",
+                            entry_point
+                        ));
                     }
                 }
                 lane_id if lane_id == AUCTION_LANE_ID => {

node/src/reactor/main_reactor/tests/transactions.rs

@@ -3825,19 +3825,15 @@ async fn successful_purse_to_account_transfer() {
     );
 }
 
-#[tokio::test]
-async fn native_transfer_deploy_with_source_purse_should_succeed() {
-    let config = SingleTransactionTestCase::default_test_config()
-        .with_pricing_handling(PricingHandling::Fixed)
-        .with_refund_handling(RefundHandling::NoRefund)
-        .with_fee_handling(FeeHandling::NoFee)
-        .with_gas_hold_balance_handling(HoldBalanceHandling::Accrued);
-
+async fn bob_transfers_to_charlie_via_native_transfer_deploy(
+    configs_override: ConfigsOverride,
+    with_source: bool,
+) -> ExecutionResult {
     let mut test = SingleTransactionTestCase::new(
         ALICE_SECRET_KEY.clone(),
         BOB_SECRET_KEY.clone(),
         CHARLIE_SECRET_KEY.clone(),
-        Some(config),
+        Some(configs_override),
     )
     .await;
 
@@ -3852,9 +3848,15 @@ async fn native_transfer_deploy_with_source_purse_should_succeed() {
         BOB_PUBLIC_KEY.to_account_hash(),
     );
 
+    let source = if with_source {
+        Some(entity.main_purse())
+    } else {
+        None
+    };
+
     let mut txn: Transaction = Deploy::native_transfer(
         CHAIN_NAME.to_string(),
-        Some(entity.main_purse()),
+        source,
         BOB_PUBLIC_KEY.clone(),
         CHARLIE_PUBLIC_KEY.clone(),
         None,
@@ -3865,43 +3867,87 @@ async fn native_transfer_deploy_with_source_purse_should_succeed() {
     .into();
     txn.sign(&BOB_SECRET_KEY);
     let (_txn_hash, _block_height, exec_result) = test.send_transaction(txn).await;
-    assert!(exec_result_is_success(&exec_result), "{:?}", exec_result);
+    exec_result
 }
 
 #[tokio::test]
-async fn native_transfer_deploy_without_source_purse_should_succeed() {
+async fn should_transfer_with_source_purse_deploy_fixed_norefund_nofee() {
     let config = SingleTransactionTestCase::default_test_config()
         .with_pricing_handling(PricingHandling::Fixed)
         .with_refund_handling(RefundHandling::NoRefund)
         .with_fee_handling(FeeHandling::NoFee)
         .with_gas_hold_balance_handling(HoldBalanceHandling::Accrued);
+    let exec_result = bob_transfers_to_charlie_via_native_transfer_deploy(config, true).await;
 
-    let mut test = SingleTransactionTestCase::new(
-        ALICE_SECRET_KEY.clone(),
-        BOB_SECRET_KEY.clone(),
-        CHARLIE_SECRET_KEY.clone(),
-        Some(config),
-    )
-    .await;
+    assert!(exec_result_is_success(&exec_result), "{:?}", exec_result);
+    assert_eq!(
+        exec_result.transfers().len(),
+        1,
+        "native transfer should have exactly 1 transfer"
+    );
+}
 
-    test.fixture
-        .run_until_consensus_in_era(ERA_ONE, ONE_MIN)
-        .await;
+#[tokio::test]
+async fn should_transfer_with_source_purse_deploy_payment_limited_refund_fee() {
+    let config = SingleTransactionTestCase::default_test_config()
+        .with_pricing_handling(PricingHandling::PaymentLimited)
+        .with_refund_handling(RefundHandling::Refund {
+            refund_ratio: Ratio::new(99, 100),
+        })
+        .with_fee_handling(FeeHandling::PayToProposer)
+        .with_gas_hold_balance_handling(HoldBalanceHandling::Accrued);
+    let exec_result = bob_transfers_to_charlie_via_native_transfer_deploy(config, true).await;
+    assert!(exec_result_is_success(&exec_result), "{:?}", exec_result);
+    assert_eq!(
+        exec_result.transfers().len(),
+        1,
+        "native transfer should have exactly 1 transfer"
+    );
+    assert_eq!(
+        exec_result.refund(),
+        Some(U512::zero()),
+        "cost should equal consumed thus no refund"
+    );
+}
+
+#[tokio::test]
+async fn should_transfer_with_main_purse_deploy_fixed_norefund_nofee() {
+    let config = SingleTransactionTestCase::default_test_config()
+        .with_pricing_handling(PricingHandling::Fixed)
+        .with_refund_handling(RefundHandling::NoRefund)
+        .with_fee_handling(FeeHandling::NoFee)
+        .with_gas_hold_balance_handling(HoldBalanceHandling::Accrued);
+    let exec_result = bob_transfers_to_charlie_via_native_transfer_deploy(config, false).await;
 
-    let mut txn: Transaction = Deploy::native_transfer(
-        CHAIN_NAME.to_string(),
-        None,
-        BOB_PUBLIC_KEY.clone(),
-        CHARLIE_PUBLIC_KEY.clone(),
-        None,
-        Timestamp::now(),
-        TimeDiff::from_seconds(600),
-        10,
-    )
-    .into();
-    txn.sign(&BOB_SECRET_KEY);
-    let (_txn_hash, _block_height, exec_result) = test.send_transaction(txn).await;
     assert!(exec_result_is_success(&exec_result), "{:?}", exec_result);
+    assert_eq!(
+        exec_result.transfers().len(),
+        1,
+        "native transfer should have exactly 1 transfer"
+    );
+}
+
+#[tokio::test]
+async fn should_transfer_with_main_purse_deploy_payment_limited_refund_fee() {
+    let config = SingleTransactionTestCase::default_test_config()
+        .with_pricing_handling(PricingHandling::PaymentLimited)
+        .with_refund_handling(RefundHandling::Refund {
+            refund_ratio: Ratio::new(99, 100),
+        })
+        .with_fee_handling(FeeHandling::PayToProposer)
+        .with_gas_hold_balance_handling(HoldBalanceHandling::Accrued);
+    let exec_result = bob_transfers_to_charlie_via_native_transfer_deploy(config, false).await;
+    assert!(exec_result_is_success(&exec_result), "{:?}", exec_result);
+    assert_eq!(
+        exec_result.transfers().len(),
+        1,
+        "native transfer should have exactly 1 transfer"
+    );
+    assert_eq!(
+        exec_result.refund(),
+        Some(U512::zero()),
+        "cost should equal consumed thus no refund"
+    );
 }
 
 #[tokio::test]
@@ -4510,7 +4556,7 @@ async fn should_allow_native_burn() {
         .with_initiator_addr(PublicKey::from(&**BOB_SECRET_KEY))
         .build()
         .unwrap();
-    let price = txn_v1
+    let payment = txn_v1
         .payment_amount()
         .expect("must have payment amount as txns are using payment_limited");
     let mut txn = Transaction::from(txn_v1);
@@ -4520,9 +4566,52 @@ async fn should_allow_native_burn() {
     let ExecutionResult::V2(result) = exec_result else {
         panic!("Expected ExecutionResult::V2 but got {:?}", exec_result);
     };
-    let expected_cost: U512 = U512::from(price) * MIN_GAS_PRICE;
+    let expected_cost: U512 = U512::from(payment) * MIN_GAS_PRICE;
+    assert_eq!(result.error_message.as_deref(), None);
+    assert_eq!(result.cost, expected_cost);
+}
+
+#[tokio::test]
+async fn should_allow_native_transfer_v1() {
+    let config = SingleTransactionTestCase::default_test_config()
+        .with_pricing_handling(PricingHandling::PaymentLimited)
+        .with_refund_handling(RefundHandling::Refund {
+            refund_ratio: Ratio::new(99, 100),
+        })
+        .with_fee_handling(FeeHandling::PayToProposer)
+        .with_gas_hold_balance_handling(HoldBalanceHandling::Accrued);
+
+    let mut test = SingleTransactionTestCase::new(
+        ALICE_SECRET_KEY.clone(),
+        BOB_SECRET_KEY.clone(),
+        CHARLIE_SECRET_KEY.clone(),
+        Some(config),
+    )
+    .await;
+
+    let transfer_amount = U512::from(100);
+
+    let txn_v1 =
+        TransactionV1Builder::new_transfer(transfer_amount, None, CHARLIE_PUBLIC_KEY.clone(), None)
+            .unwrap()
+            .with_chain_name(CHAIN_NAME)
+            .with_initiator_addr(PublicKey::from(&**BOB_SECRET_KEY))
+            .build()
+            .unwrap();
+    let payment = txn_v1
+        .payment_amount()
+        .expect("must have payment amount as txns are using payment_limited");
+    let mut txn = Transaction::from(txn_v1);
+    txn.sign(&BOB_SECRET_KEY);
+
+    let (_txn_hash, _block_height, exec_result) = test.send_transaction(txn).await;
+    let ExecutionResult::V2(result) = exec_result else {
+        panic!("Expected ExecutionResult::V2 but got {:?}", exec_result);
+    };
+    let expected_cost: U512 = U512::from(payment) * MIN_GAS_PRICE;
     assert_eq!(result.error_message.as_deref(), None);
     assert_eq!(result.cost, expected_cost);
+    assert_eq!(result.transfers.len(), 1, "should have exactly 1 transfer");
 }
 
 #[tokio::test]

types/src/execution/execution_result.rs

@@ -37,11 +37,11 @@ pub enum ExecutionResult {
 }
 
 impl ExecutionResult {
-    /// Returns refund amount.
-    pub fn refund(&self) -> Option<U512> {
+    /// Returns cost.
+    pub fn cost(&self) -> U512 {
         match self {
-            ExecutionResult::V1(_) => None,
-            ExecutionResult::V2(result) => Some(result.refund),
+            ExecutionResult::V1(result) => result.cost(),
+            ExecutionResult::V2(result) => result.cost,
         }
     }
 
@@ -53,6 +53,14 @@ impl ExecutionResult {
         }
     }
 
+    /// Returns refund amount.
+    pub fn refund(&self) -> Option<U512> {
+        match self {
+            ExecutionResult::V1(_) => None,
+            ExecutionResult::V2(result) => Some(result.refund),
+        }
+    }
+
     /// Returns a random ExecutionResult.
     #[cfg(any(feature = "testing", test))]
     pub fn random(rng: &mut TestRng) -> Self {

types/src/lib.rs

@@ -186,6 +186,7 @@ pub use semver::{ParseSemVerError, SemVer, SEM_VER_SERIALIZED_LENGTH};
 pub use stored_value::{
     GlobalStateIdentifier, StoredValue, StoredValueTag, TypeMismatch as StoredValueTypeMismatch,
 };
+pub use system::mint::METHOD_TRANSFER;
 pub use tagged::Tagged;
 #[cfg(any(feature = "std", test))]
 pub use timestamp::serde_option_time_diff;

types/src/transaction/deploy/executable_deploy_item.rs

@@ -24,7 +24,7 @@ use crate::{
     system::mint::ARG_AMOUNT,
     transaction::{RuntimeArgs, TransferTarget},
     AddressableEntityHash, AddressableEntityIdentifier, Gas, Motes, PackageIdentifier, Phase, URef,
-    U512,
+    METHOD_TRANSFER, U512,
 };
 #[cfg(any(feature = "testing", test))]
 use crate::{testing::TestRng, CLValue};
@@ -255,9 +255,8 @@ impl ExecutableDeployItem {
     /// Returns the entry point name.
     pub fn entry_point_name(&self) -> &str {
         match self {
-            ExecutableDeployItem::ModuleBytes { .. } | ExecutableDeployItem::Transfer { .. } => {
-                DEFAULT_ENTRY_POINT_NAME
-            }
+            ExecutableDeployItem::ModuleBytes { .. } => DEFAULT_ENTRY_POINT_NAME,
+            ExecutableDeployItem::Transfer { .. } => METHOD_TRANSFER,
             ExecutableDeployItem::StoredVersionedContractByName { entry_point, .. }
             | ExecutableDeployItem::StoredVersionedContractByHash { entry_point, .. }
             | ExecutableDeployItem::StoredContractByHash { entry_point, .. }