feat: new generic service-consumer contract for pallet-smart-contract

.github/workflows/build_test.yaml

@@ -47,3 +47,15 @@ jobs:
           cd substrate-node/tests
           robot -d _output_tests/ .
 
+      - uses: actions/upload-artifact@v3
+        if: failure()
+        with:
+          name: integration test output
+          path: substrate-node/tests/_output_tests/
+
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: integration test output
+          path: substrate-node/tests/_output_tests/
+

docs/architecture/0002-smart-contract-billing-changed.md

@@ -0,0 +1,28 @@
+# 2. Changed smart contract billing workflow
+
+Date: 2022-10-12
+
+## Status
+
+Accepted
+
+## Context
+
+TFchain bills contract using an internal feature of susbtrate called `on_finalize`. This function / hook is executed after every block, in this function the time to compute is limited since this runs before the block production is finished. We are worried that if the usage of the grid grows, this on finalize method would need to do too much computations and that the block time would be impacted.
+
+## Decision
+
+We searched for an alternative to this `on_finalize` method within the substrate framework. We found a hook that fires after a block is produced, but in that hook the result of some computation must be submitted onchain with an extrinsic. This offchain worker cannot modify chain storage directly, rather it can only do that through an extrinsic.
+
+## Consequences
+
+### the good
+
+- The billing for a contract is now executed after a block is produced and not within that same block.
+- Atleast one offchain worker must run with the `smct` keytype in order to bill contracts.
+- Contracts billing cycles do not rely anymore on a previously successful bill.
+- External users can call `bill_contract` but don't need to.
+
+### the worrying
+
+- If no validators run an offchain worker with the `smct` keytype, no contracts will be billed.

substrate-node/charts/substrate-node/Chart.yaml

@@ -2,5 +2,5 @@ apiVersion: v2
 name: substrate-node
 description: Tfchain node
 type: application
-version: 0.2.4
+version: 0.2.5
 appVersion: "2.1.1"

substrate-node/charts/substrate-node/templates/deployment.yaml

@@ -155,6 +155,25 @@ spec:
             - name: keys
               mountPath: /keys
               readOnly: true
+        - name: insert-smct-key
+          securityContext:
+            {{- toYaml .Values.securityContext | nindent 12 }}
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          args: [
+            "key",
+            "insert",
+            "--keystore-path=/keystore",
+            "--key-type", "smct",
+            "--suri","/keys/scmt",
+            "--scheme=sr25519"
+          ]
+          volumeMounts:
+            - name: keystore
+              mountPath: /keystore
+            - name: keys
+              mountPath: /keys
+              readOnly: true
       {{ end }}
       volumes:
         - name: keystore

substrate-node/charts/substrate-node/values.yaml

@@ -60,6 +60,9 @@ keys: []
 #   secret: 1a...
 # - name: tft
 #   secret: "kkjghjfkkj kjhgkkhhgg"
+## Smart contract billing offchain worker key
+# - name: smct
+#   secret: "fsfdsfsdf"
 
 # boot_node: "/ip4/10.42.1.134/tcp/30333/p2p/12D3KooWGX8JFxZu2dDmGVpa9t9enZnFCLhH4NUBA7PDuhEVQTMg"
 

substrate-node/pallets/pallet-dao/src/lib.rs

@@ -523,10 +523,10 @@ impl<T: Config> ChangeNode<PubConfigOf<T>, InterfaceOf<T>> for Pallet<T> {
         old_node: Option<&Node<PubConfigOf<T>, InterfaceOf<T>>>,
         new_node: &Node<PubConfigOf<T>, InterfaceOf<T>>,
     ) {
-        let new_node_weight = Self::get_node_weight(new_node.resources);
+        let new_node_weight = Self::get_node_weight(new_node.resources.total_resources);
         match old_node {
             Some(node) => {
-                let old_node_weight = Self::get_node_weight(node.resources);
+                let old_node_weight = Self::get_node_weight(node.resources.total_resources);
 
                 if node.farm_id != new_node.farm_id {
                     let mut old_farm_weight = FarmWeight::<T>::get(node.farm_id);
@@ -554,7 +554,7 @@ impl<T: Config> ChangeNode<PubConfigOf<T>, InterfaceOf<T>> for Pallet<T> {
     }
 
     fn node_deleted(node: &Node<PubConfigOf<T>, InterfaceOf<T>>) {
-        let node_weight = Self::get_node_weight(node.resources);
+        let node_weight = Self::get_node_weight(node.resources.total_resources);
         let mut farm_weight = FarmWeight::<T>::get(node.farm_id);
         farm_weight = farm_weight.checked_sub(node_weight).unwrap_or(0);
         FarmWeight::<T>::insert(node.farm_id, farm_weight);

substrate-node/pallets/pallet-smart-contract/Cargo.toml

@@ -45,6 +45,11 @@ sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-
 # Benchmarking
 frame-benchmarking = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24", default-features = false, optional = true }
 
+[dev-dependencies]
+parking_lot = '0.12.1'
+sp-keystore =  { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.24", default-features = false }
+env_logger = "*"
+
 [features]
 default = ['std']
 std = [

substrate-node/pallets/pallet-smart-contract/src/cost.rs

@@ -53,58 +53,47 @@ impl<T: Config> Contract<T> {
         seconds_elapsed: u64,
     ) -> Result<u64, DispatchErrorWithPostInfo> {
         let total_cost = match &self.contract_type {
-            // Calculate total cost for a node contract
-            types::ContractData::NodeContract(node_contract) => {
+            types::ContractData::DeploymentContract(_) => {
+                // cost is calculated in capacity reservation contracts
+                0
+            }
+            types::ContractData::CapacityReservationContract(capacity_reservation_contract) => {
                 // Get the contract billing info to view the amount unbilled for NRU (network resource units)
                 let contract_billing_info = self.get_billing_info();
                 // Get the node
-                if !pallet_tfgrid::Nodes::<T>::contains_key(node_contract.node_id) {
-                    return Err(DispatchErrorWithPostInfo::from(Error::<T>::NodeNotExists));
-                }
-
-                // We know the contract is using resources, now calculate the cost for each used resource
-
-                let node_contract_resources =
-                    pallet::Pallet::<T>::node_contract_resources(self.contract_id);
-
-                let mut bill_resources = true;
-                // If this node contract is deployed on a node which has a rent contract
-                // We can ignore billing for the resources used by this node contract
-                if pallet::ActiveRentContractForNode::<T>::contains_key(node_contract.node_id) {
-                    bill_resources = false
-                }
+                let node = pallet_tfgrid::Nodes::<T>::get(capacity_reservation_contract.node_id)
+                    .ok_or(Error::<T>::NodeNotExists)?;
 
                 let contract_cost = calculate_resources_cost::<T>(
-                    node_contract_resources.used,
-                    node_contract.public_ips,
+                    capacity_reservation_contract.resources.total_resources,
+                    capacity_reservation_contract.public_ips,
                     seconds_elapsed,
                     &pricing_policy,
-                    bill_resources,
                 );
-                contract_cost + contract_billing_info.amount_unbilled
-            }
-            types::ContractData::RentContract(rent_contract) => {
-                if !pallet_tfgrid::Nodes::<T>::contains_key(rent_contract.node_id) {
-                    return Err(DispatchErrorWithPostInfo::from(Error::<T>::NodeNotExists));
+                if node.resources.total_resources
+                    == capacity_reservation_contract.resources.total_resources
+                {
+                    Percent::from_percent(pricing_policy.discount_for_dedication_nodes)
+                        * contract_cost
+                        + contract_billing_info.amount_unbilled
+                } else {
+                    contract_cost + contract_billing_info.amount_unbilled
                 }
-                let node = pallet_tfgrid::Nodes::<T>::get(rent_contract.node_id).unwrap();
-
-                let contract_cost = calculate_resources_cost::<T>(
-                    node.resources,
-                    0,
-                    seconds_elapsed,
-                    &pricing_policy,
-                    true,
-                );
-                Percent::from_percent(pricing_policy.discount_for_dedication_nodes) * contract_cost
             }
-            // Calculate total cost for a name contract
             types::ContractData::NameContract(_) => {
                 // bill user for name usage for number of seconds elapsed
                 let total_cost_u64f64 = (U64F64::from_num(pricing_policy.unique_name.value) / 3600)
                     * U64F64::from_num(seconds_elapsed);
                 total_cost_u64f64.to_num::<u64>()
             }
+            types::ContractData::ServiceContract(service_contract) => {
+                // bill user for service usage for number of seconds elapsed
+                let bill_window = 0; // TODO
+                let contract_cost = (U64F64::from_num(service_contract.base_fee * bill_window)
+                    / 3600)
+                    + U64F64::from_num(service_contract.variable_fee);
+                contract_cost.to_num::<u64>()
+            }
         };
 
         Ok(total_cost)
@@ -117,32 +106,26 @@ pub fn calculate_resources_cost<T: Config>(
     ipu: u32,
     seconds_elapsed: u64,
     pricing_policy: &pallet_tfgrid_types::PricingPolicy<T::AccountId>,
-    bill_resources: bool,
 ) -> u64 {
-    let mut total_cost = U64F64::from_num(0);
-
-    if bill_resources {
-        let hru = U64F64::from_num(resources.hru) / pricing_policy.su.factor_base_1024();
-        let sru = U64F64::from_num(resources.sru) / pricing_policy.su.factor_base_1024();
-        let mru = U64F64::from_num(resources.mru) / pricing_policy.cu.factor_base_1024();
-        let cru = U64F64::from_num(resources.cru);
-
-        let su_used = hru / 1200 + sru / 200;
-        // the pricing policy su cost value is expressed in 1 hours or 3600 seconds.
-        // we bill every 3600 seconds but here we need to calculate the cost per second and multiply it by the seconds elapsed.
-        let su_cost = (U64F64::from_num(pricing_policy.su.value) / 3600)
-            * U64F64::from_num(seconds_elapsed)
-            * su_used;
-        log::debug!("su cost: {:?}", su_cost);
-
-        let cu = calculate_cu(cru, mru);
-
-        let cu_cost = (U64F64::from_num(pricing_policy.cu.value) / 3600)
-            * U64F64::from_num(seconds_elapsed)
-            * cu;
-        log::debug!("cu cost: {:?}", cu_cost);
-        total_cost = su_cost + cu_cost;
-    }
+    let hru = U64F64::from_num(resources.hru) / pricing_policy.su.factor_base_1024();
+    let sru = U64F64::from_num(resources.sru) / pricing_policy.su.factor_base_1024();
+    let mru = U64F64::from_num(resources.mru) / pricing_policy.cu.factor_base_1024();
+    let cru = U64F64::from_num(resources.cru);
+
+    let su_used = hru / 1200 + sru / 200;
+    // the pricing policy su cost value is expressed in 1 hours or 3600 seconds.
+    // we bill every 3600 seconds but here we need to calculate the cost per second and multiply it by the seconds elapsed.
+    let su_cost = (U64F64::from_num(pricing_policy.su.value) / 3600)
+        * U64F64::from_num(seconds_elapsed)
+        * su_used;
+    log::debug!("su cost: {:?}", su_cost);
+
+    let cu = calculate_cu(cru, mru);
+
+    let cu_cost =
+        (U64F64::from_num(pricing_policy.cu.value) / 3600) * U64F64::from_num(seconds_elapsed) * cu;
+    log::debug!("cu cost: {:?}", cu_cost);
+    let mut total_cost = su_cost + cu_cost;
 
     if ipu > 0 {
         let total_ip_cost = U64F64::from_num(ipu)