A0-1610: Contract support redux

.github/actions/run-e2e-test/action.yml

@@ -26,6 +26,10 @@ inputs:
   follow-up-finalization-check:
     description: 'Whether to run a follow-up finalization check.'
     required: false
+  deploy-adder:
+    description: 'Whether to deploy the adder sample contract to the node.'
+    required: false
+    default: 'false'
 
 runs:
   using: 'composite'
@@ -84,6 +88,14 @@ runs:
           )
         fi
 
+        DEPLOY_ADDER="${{ inputs.deploy-adder }}"
+
+        if [[ "${DEPLOY_ADDER}" = "true" ]]; then
+          pushd contracts/adder
+          export ADDER=$(./deploy.sh)
+          popd
+        fi
+
         ./.github/scripts/run_e2e_test.sh "${ARGS[@]}"
 
     - name: Run finalization e2e test

.github/scripts/run_e2e_test.sh

@@ -111,6 +111,11 @@ if [[ -n "${ONLY_LEGACY:-}" ]]; then
     ARGS+=(-e ONLY_LEGACY)
 fi
 
-docker run -v $(pwd)/docker/data:/data "${ARGS[@]}" aleph-e2e-client:latest
+if [[ -n "${ADDER:-}" ]]; then
+    ARGS+=(-e "ADDER=${ADDER}")
+    ARGS+=(-e "ADDER_METADATA=/contracts/adder/target/ink/metadata.json")
+fi
+
+docker run -v "$(pwd)/contracts:/contracts" -v "$(pwd)/docker/data:/data" "${ARGS[@]}" aleph-e2e-client:latest
 
 exit $?

.github/workflows/build-and-push-cliain.yaml

@@ -21,6 +21,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Cargo | Build release binary
         run: |

.github/workflows/build-node-and-runtime.yml

@@ -37,6 +37,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install WASM target
         run: rustup target add wasm32-unknown-unknown

.github/workflows/build-send-postsync-hook-runtime-image.yml

@@ -37,6 +37,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Build binary
         run: |

.github/workflows/check-excluded-packages.yml

@@ -31,12 +31,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'
-
-      - name: Install clippy and fmt
-        run: rustup component add clippy rustfmt
-
-      - name: Install WASM target
-        run: rustup target add wasm32-unknown-unknown
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Read excluded packages from Cargo.toml
         id: read_excluded
@@ -75,6 +70,8 @@ jobs:
           do
             echo "Checking package $p..."
             pushd "$p"
+            rustup component add clippy rustfmt
+            rustup target add wasm32-unknown-unknown
             cargo fmt --all --check
             cargo clippy --all-features -- --no-deps -D warnings
             popd

.github/workflows/e2e-tests-main-devnet.yml

@@ -69,6 +69,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Restore cache
         uses: ./.github/actions/restore-cache
@@ -116,6 +117,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install WASM target
         run: rustup target add wasm32-unknown-unknown
@@ -154,6 +156,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Restore cache
         uses: ./.github/actions/restore-cache
@@ -552,6 +555,31 @@ jobs:
           UPGRADE_FINALIZATION_WAIT_SESSIONS: 2
         timeout-minutes: 10
 
+  run-e2e-adder-contract-test:
+    needs: [build-test-docker, build-test-client]
+    name: Run e2e adder contract test
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v2
+
+      - name: Install cargo-contract
+        uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-contract
+          version: "2.0.0-beta.1"
+
+      - name: Install rust-src
+        working-directory: ./contracts
+        run: rustup component add rust-src
+
+      - name: Run e2e test
+        uses: ./.github/actions/run-e2e-test
+        with:
+          deploy-adder: true
+          test-case: adder
+        timeout-minutes: 10
+
 # The tests below were written under the assumption that nonfinalized blocks are being produced, they need a rewrite before being reenabled.
 # TODO(A0-1644): Reenable these tests.
 #  run-e2e-failing-version-upgrade:
@@ -659,6 +687,7 @@ jobs:
       run-e2e-ban-threshold,
       run-e2e-version-upgrade,
       run-e2e-permissionless-ban,
+      run-e2e-adder-contract-test,
 #      run-e2e-failing-version-upgrade,
 #      run-e2e-version-upgrade-catchup,
     ]
@@ -814,6 +843,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install WASM target
         run: rustup target add wasm32-unknown-unknown

.github/workflows/nightly-pipeline.yaml

@@ -60,6 +60,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install WASM target
         run: rustup target add wasm32-unknown-unknown
@@ -97,6 +98,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Restore cache
         uses: ./.github/actions/restore-cache

.github/workflows/unit_tests.yml

@@ -31,6 +31,7 @@ jobs:
         uses: arduino/setup-protoc@v1
         with:
           version: '3.6.1'        
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install clippy and fmt
         run: rustup component add clippy rustfmt

Cargo.toml

@@ -18,6 +18,7 @@ exclude = [
   "fork-off",
   "benches/payout-stakers",
   "bin/cliain",
+  "contracts/adder"
 ]
 
 [profile.release]

aleph-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "aleph_client"
-version = "2.4.0"
+version = "2.5.0"
 edition = "2021"
 license = "Apache 2.0"
 

aleph-client/src/connections.rs

@@ -142,12 +142,14 @@ impl SignedConnection {
         if let Some(details) = tx.validation_details() {
             info!(target:"aleph-client", "Sending extrinsic {}.{} with params: {:?}", details.pallet_name, details.call_name, params);
         }
+
         let progress = self
             .connection
             .client
             .tx()
             .sign_and_submit_then_watch(&tx, &self.signer, params)
-            .await?;
+            .await
+            .map_err(|e| anyhow!("Failed to submit transaction: {:?}", e))?;
 
         // In case of Submitted hash does not mean anything
         let hash = match status {

aleph-client/src/contract/convertible_value.rs

@@ -0,0 +1,120 @@
+use std::{ops::Deref, str::FromStr};
+
+use anyhow::{anyhow, bail, Result};
+use contract_transcode::Value;
+
+use crate::AccountId;
+
+/// Temporary wrapper for converting from [Value] to primitive types.
+///
+/// ```
+/// # #![feature(assert_matches)]
+/// # #![feature(type_ascription)]
+/// # use std::assert_matches::assert_matches;
+/// # use anyhow::{anyhow, Result};
+/// # use aleph_client::{AccountId, contract::ConvertibleValue};
+/// use contract_transcode::Value;
+///
+/// assert_matches!(ConvertibleValue(Value::UInt(42)).try_into(), Ok(42u128));
+/// assert_matches!(ConvertibleValue(Value::UInt(42)).try_into(), Ok(42u32));
+/// assert_matches!(ConvertibleValue(Value::UInt(u128::MAX)).try_into(): Result<u32>, Err(_));
+/// assert_matches!(ConvertibleValue(Value::Bool(true)).try_into(), Ok(true));
+/// assert_matches!(
+///     ConvertibleValue(Value::Literal("5H8cjBBzCJrAvDn9LHZpzzJi2UKvEGC9VeVYzWX5TrwRyVCA".to_string())).
+///         try_into(): Result<AccountId>,
+///     Ok(_)
+/// );
+/// assert_matches!(
+///     ConvertibleValue(Value::String("not a number".to_string())).try_into(): Result<u128>,
+///     Err(_)
+/// );
+/// ```
+#[derive(Debug, Clone)]
+pub struct ConvertibleValue(pub Value);
+
+impl Deref for ConvertibleValue {
+    type Target = Value;
+
+    fn deref(&self) -> &Value {
+        &self.0
+    }
+}
+
+impl TryFrom<ConvertibleValue> for bool {
+    type Error = anyhow::Error;
+
+    fn try_from(value: ConvertibleValue) -> Result<bool, Self::Error> {
+        match value.0 {
+            Value::Bool(value) => Ok(value),
+            _ => bail!("Expected {:?} to be a boolean", value.0),
+        }
+    }
+}
+
+impl TryFrom<ConvertibleValue> for u128 {
+    type Error = anyhow::Error;
+
+    fn try_from(value: ConvertibleValue) -> Result<u128, Self::Error> {
+        match value.0 {
+            Value::UInt(value) => Ok(value),
+            _ => bail!("Expected {:?} to be an integer", value.0),
+        }
+    }
+}
+
+impl TryFrom<ConvertibleValue> for u32 {
+    type Error = anyhow::Error;
+
+    fn try_from(value: ConvertibleValue) -> Result<u32, Self::Error> {
+        match value.0 {
+            Value::UInt(value) => Ok(value.try_into()?),
+            _ => bail!("Expected {:?} to be an integer", value.0),
+        }
+    }
+}
+
+impl TryFrom<ConvertibleValue> for AccountId {
+    type Error = anyhow::Error;
+
+    fn try_from(value: ConvertibleValue) -> Result<AccountId, Self::Error> {
+        match value.0 {
+            Value::Literal(value) => {
+                AccountId::from_str(&value).map_err(|_| anyhow!("Invalid account id"))
+            }
+            _ => bail!("Expected {:?} to be a string", value),
+        }
+    }
+}
+
+impl<T> TryFrom<ConvertibleValue> for Result<T>
+where
+    ConvertibleValue: TryInto<T, Error = anyhow::Error>,
+{
+    type Error = anyhow::Error;
+
+    fn try_from(value: ConvertibleValue) -> Result<Result<T>, Self::Error> {
+        if let Value::Tuple(tuple) = &value.0 {
+            match tuple.ident() {
+                Some(x) if x == "Ok" => {
+                    if tuple.values().count() == 1 {
+                        let item =
+                            ConvertibleValue(tuple.values().next().unwrap().clone()).try_into()?;
+                        return Ok(Ok(item));
+                    } else {
+                        bail!("Unexpected number of elements in Ok variant: {:?}", &value);
+                    }
+                }
+                Some(x) if x == "Err" => {
+                    if tuple.values().count() == 1 {
+                        return Ok(Err(anyhow!(value.to_string())));
+                    } else {
+                        bail!("Unexpected number of elements in Err variant: {:?}", &value);
+                    }
+                }
+                _ => (),
+            }
+        }
+
+        bail!("Expected {:?} to be an Ok(_) or Err(_) tuple.", value);
+    }
+}