feat(engine)!: charge storage as a transaction writes it - #2418

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: All committee members restart after consensus stalls before an epoch boundary
   ✔  Given a network with spec
      
      validators:
        - name: VN1
        - name: VN2
        - name: VN3
        - name: VN4
   ✔  Then miner MINER mines to the next epoch
   ✔  When all validator nodes have started epoch 4
   ✔  Then miner MINER mines to the next epoch
   ✔  When all validator nodes have started epoch 5
   ✘  Then I create an account ACC_1 via the wallet daemon WALLETD with 10000 XTR
      Step failed:
      Defined: tests/features/stall_recovery.feature:24:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:205:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "All committee members restart after consensus stalls before an epoch boundary",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC_1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Rollback, restart, and continue producing blocks
   ✔  Given a network with spec
      
      validators:
        - name: VN1
        - name: VN2
   ✔  Then miner MINER mines to the next epoch
   ✔  When all validator nodes have started epoch 4
   ✔  Then miner MINER mines to the next epoch
   ✔  When all validator nodes have started epoch 5
   ✘  Then I create an account ACC_1 via the wallet daemon WALLETD with 10000 XTR
      Step failed:
      Defined: tests/features/offline_rollback.feature:22:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:205:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Rollback, restart, and continue producing blocks",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC_1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Leader failure with single committee
   ✔  Given a network with spec
      
      validators:
        - name: VN1
        - name: VN2
        - name: VN3
        - name: VN4
   ✘  Then I create an account ACC_1 via the wallet daemon WALLETD with 10000 XTR
      Step failed:
      Defined: tests/features/leader_failure.feature:17:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:205:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Leader failure with single committee",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC_1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Concurrent calls to the counter template
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 2 XTR
      Step failed:
      Defined: tests/features/concurrency.feature:11:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Concurrent calls to the counter template",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Claim validator fees
   ✔  Given a network with spec
      
      validators:
        - name: VN
          fee_claim_account: VN_FEES
      walletds:
        - name: WALLET_D
          with_account: VN_FEES
      indexer:
        name: IDX
   ✘  When I create an account ACC1 via the wallet daemon WALLET_D with 10 XTR
      Step failed:
      Defined: tests/features/claim_fees.feature:22:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Claim validator fees",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "VN_FEES",
              "ACC1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Prevent double claim of validator fees
   ✔  Given a network with spec
      
      validators:
        - name: VN
          fee_claim_account: VN_FEES
      walletds:
        - name: WALLET_D
          with_account: VN_FEES
      indexer:
        name: IDX
   ✘  When I create an account ACC1 via the wallet daemon WALLET_D with 10 XTR
      Step failed:
      Defined: tests/features/claim_fees.feature:53:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Prevent double claim of validator fees",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "VN_FEES",
              "ACC1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Template registration and invocation in a 2-VN committee
   ✔  Given a network with spec
      
      validators:
        - name: VN1
        - name: VN2
   ✘  When I create an account ACC via the wallet daemon WALLETD with 10000 XTR
      Step failed:
      Defined: tests/features/committee.feature:18:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Template registration and invocation in a 2-VN committee",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Template registration and invocation in a 4-VN committee
   ✔  Given a network with spec
      
      validators:
        - name: VN1
        - name: VN2
        - name: VN3
        - name: VN4
   ✘  When I create an account ACC via the wallet daemon WALLETD with 10000 XTR
      Step failed:
      Defined: tests/features/committee.feature:34:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Template registration and invocation in a 4-VN committee",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Transfer confidential tokens between accounts
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACCOUNT_1 via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/confidential.feature:11:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Transfer confidential tokens between accounts",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACCOUNT_1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Counter template registration and invocation once
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 2 XTR
      Step failed:
      Defined: tests/features/counter.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Counter template registration and invocation once",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Counter template registration and invocation multiple times
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 2 XTR
      Step failed:
      Defined: tests/features/counter.feature:32:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Counter template registration and invocation multiple times",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: EndEpoch command is used on epoch change
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 2 XTR
      Step failed:
      Defined: tests/features/epoch_change.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "EndEpoch command is used on epoch change",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Offline validator gets evicted
   ✔  Given a network with spec
      
      validators:
        - name: VN1
        - name: VN2
        - name: VN3
        - name: VN4
        - name: VN5
      walletds:
          - name: WALLET_D
   ✔  When all validator nodes have started epoch 3
   ✘  Then I create an account ACC_1 via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/eviction.feature:24:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:205:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Offline validator gets evicted",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC_1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Mint fungible tokens
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 2 XTR
      Step failed:
      Defined: tests/features/fungible.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Mint fungible tokens",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Wallet daemon is able to connect to indexer
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10 XTR
      Step failed:
      Defined: tests/features/indexer.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Wallet daemon is able to connect to indexer",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Indexer GraphQL requests events over network substate indexing
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC_1 via the wallet daemon WALLET_D with 1 XTR
      Step failed:
      Defined: tests/features/indexer.feature:72:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Indexer GraphQL requests events over network substate indexing",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC_1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Indexer GraphQL filtering and pagination of events
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/indexer.feature:87:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Indexer GraphQL filtering and pagination of events",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Indexer template catalogue is populated after template publication
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10 XTR
      Step failed:
      Defined: tests/features/indexer.feature:129:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Indexer template catalogue is populated after template publication",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Indexer template catalogue pagination works
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10 XTR
      Step failed:
      Defined: tests/features/indexer.feature:153:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Indexer template catalogue pagination works",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Mint, mutate and burn non fungible tokens
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/nft.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Mint, mutate and burn non fungible tokens",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Create resource and mint in one transaction
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/nft.feature:64:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Create resource and mint in one transaction",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: New validator node registers and syncs
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC1 via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/state_sync.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "New validator node registers and syncs",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC1",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Transactions with DOWN local substates are rejected
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10 XTR
      Step failed:
      Defined: tests/features/substates.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Transactions with DOWN local substates are rejected",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Transfer tokens to account that does not previously exist
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/transfer.feature:12:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Transfer tokens to account that does not previously exist",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }

Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
  Scenario: Transfer tokens to existing account
   ✔  Given a network with registered validator VN and wallet daemon WALLET_D
   ✘  When I create an account ACC via the wallet daemon WALLET_D with 10000 XTR
      Step failed:
      Defined: tests/features/transfer.feature:66:5
      Matched: integration_tests/tests/steps/wallet_daemon.rs:206:1
      Step panicked. Captured output: called `Result::unwrap()` on an `Err` value: RequestFailedWithStatus { code: 1000, message: "Application error: 1000: Application error: 'Transaction rejected: Insufficient fees paid: Required fees 2548 but 1500 paid" }
      TariWorld {
          base_nodes: [],
          wallets: [],
          validator_nodes: [],
          indexers: [],
          vn_seeds: [],
          miners: [],
          templates: [],
          outputs: [],
          http_server: None,
          template_mock_server_port: None,
          current_scenario_name: Some(
              "Transfer tokens to existing account",
          ),
          claim_proofs: [],
          addresses: [],
          num_databases_saved: 0,
          wallet_accounts: [
              "ACC",
          ],
          wallet_daemons: [],
      }