Support different Soroban storage types (#1664)

Author: salaheldinsoliman

fmt/src/formatter.rs

@@ -20,7 +20,7 @@ use crate::{
 };
 use alloy_primitives::Address;
 use itertools::{Either, Itertools};
-use solang_parser::pt::{PragmaDirective, VersionComparator};
+use solang_parser::pt::{PragmaDirective, StorageType, VersionComparator};
 use std::{fmt::Write, str::FromStr};
 use thiserror::Error;
 
@@ -3333,6 +3333,11 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
                 self.visit_list("", idents, Some(loc.start()), Some(loc.end()), false)?;
                 None
             }
+            VariableAttribute::StorageType(s) => match s {
+                StorageType::Instance(_) => Some("instance".to_string()),
+                StorageType::Temporary(_) => Some("temporary".to_string()),
+                StorageType::Persistent(_) => Some("persistent".to_string()),
+            },
         };
         if let Some(token) = token {
             let loc = attribute.loc();

fmt/src/solang_ext/ast_eq.rs

@@ -75,6 +75,17 @@ impl AstEq for VariableDefinition {
     }
 }
 
+impl AstEq for StorageType {
+    fn ast_eq(&self, other: &Self) -> bool {
+        matches!(
+            (self, other),
+            (StorageType::Instance(_), StorageType::Instance(_))
+                | (StorageType::Persistent(_), StorageType::Persistent(_))
+                | (StorageType::Temporary(_), StorageType::Temporary(_))
+        )
+    }
+}
+
 impl AstEq for FunctionDefinition {
     fn ast_eq(&self, other: &Self) -> bool {
         // attributes
@@ -726,5 +737,6 @@ derive_ast_eq! { enum VariableAttribute {
     Constant(loc),
     Immutable(loc),
     Override(loc, idents),
+    StorageType(s)
     _
 }}

integration/polkadot/try_catch.sol

@@ -2,9 +2,9 @@ contract TryCatchCaller {
     constructor() payable {}
 
     function test(uint128 div) public payable returns (uint128) {
-        TryCatchCallee instance = new TryCatchCallee();
+        TryCatchCallee contract_instance = new TryCatchCallee();
 
-        try instance.test(div) returns (uint128) {
+        try contract_instance.test(div) returns (uint128) {
             return 4;
         } catch Error(string reason) {
             assert(reason == "foo");

integration/soroban/.gitignore

@@ -1,4 +1,3 @@
-*.js
 *.so
 *.key
 *.json

integration/soroban/package.json

@@ -7,9 +7,9 @@
       "mocha": "^10.4.0"
     },
     "scripts": {
-      "build": "solang compile *.sol --target soroban",
+      "build": "solang compile *.sol --target soroban && solang compile storage_types.sol --target soroban --release",
       "setup": "node setup.js",
-      "test": "mocha *.spec.js --timeout 20000"
+      "test": "mocha *.spec.js --timeout 100000"
     },
     "devDependencies": {
       "@eslint/js": "^9.4.0",

integration/soroban/runtime_error.spec.js

@@ -0,0 +1,48 @@
+import * as StellarSdk from '@stellar/stellar-sdk';
+import { readFileSync } from 'fs';
+import { expect } from 'chai';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { call_contract_function } from './test_helpers.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(__filename);
+
+describe('Runtime Error', () => {
+  let keypair;
+  const server = new StellarSdk.SorobanRpc.Server(
+    "https://soroban-testnet.stellar.org:443",
+  );
+
+  let contractAddr;
+  let contract;
+  before(async () => {
+
+    console.log('Setting up runtime_error.sol contract tests...');
+
+    // read secret from file
+    const secret = readFileSync('alice.txt', 'utf8').trim();
+    keypair = StellarSdk.Keypair.fromSecret(secret);
+
+    let contractIdFile = path.join(dirname, '.soroban', 'contract-ids', 'Error.txt');
+    // read contract address from file
+    contractAddr = readFileSync(contractIdFile, 'utf8').trim().toString();
+
+    // load contract
+    contract = new StellarSdk.Contract(contractAddr);
+
+    // call decrement once. The second call however will result in a runtime error
+    await call_contract_function("decrement", server, keypair, contract);
+  });
+
+  it('get correct initial counter', async () => {
+
+    // decrement the counter again, resulting in a runtime error
+    let res = await call_contract_function("decrement", server, keypair, contract);
+
+    expect(res).to.contain('runtime_error: math overflow in runtime_error.sol:6:9-19');
+  });
+
+});
+
+

integration/soroban/storage_types.sol

@@ -0,0 +1,21 @@
+contract storage_types {
+            
+    uint64 public temporary sesa = 1;
+    uint64 public instance sesa1 = 1;
+    uint64 public persistent sesa2 = 2;
+    uint64 public sesa3 = 2;
+
+    function inc() public {
+        sesa++;
+        sesa1++;
+        sesa2++;
+        sesa3++;
+    }
+
+    function dec() public {
+        sesa--;
+        sesa1--;
+        sesa2--;
+        sesa3--;
+    }
+}

integration/soroban/storage_types.spec.js

@@ -0,0 +1,84 @@
+import * as StellarSdk from '@stellar/stellar-sdk';
+import { readFileSync } from 'fs';
+import { expect } from 'chai';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { call_contract_function } from './test_helpers.js';  // Helper to interact with the contract
+
+const __filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(__filename);
+
+describe('StorageTypes', () => {
+  let keypair;
+  const server = new StellarSdk.SorobanRpc.Server(
+    "https://soroban-testnet.stellar.org:443",
+  );
+
+  let contractAddr;
+  let contract;
+  before(async () => {
+    console.log('Setting up storage_types contract tests...');
+
+    // Read secret from file
+    const secret = readFileSync('alice.txt', 'utf8').trim();
+    keypair = StellarSdk.Keypair.fromSecret(secret);
+
+    let contractIdFile = path.join(dirname, '.soroban', 'contract-ids', 'storage_types.txt');
+    // Read contract address from file
+    contractAddr = readFileSync(contractIdFile, 'utf8').trim().toString();
+
+    // Load contract
+    contract = new StellarSdk.Contract(contractAddr);
+  });
+
+  it('check initial values', async () => {
+    // Check initial values of all storage variables
+    let sesa = await call_contract_function("sesa", server, keypair, contract);
+    expect(sesa.toString()).eq("1");
+
+    let sesa1 = await call_contract_function("sesa1", server, keypair, contract);
+    expect(sesa1.toString()).eq("1");
+
+    let sesa2 = await call_contract_function("sesa2", server, keypair, contract);
+    expect(sesa2.toString()).eq("2");
+
+    let sesa3 = await call_contract_function("sesa3", server, keypair, contract);
+    expect(sesa3.toString()).eq("2");
+  });
+
+  it('increment values', async () => {
+    // Increment all values by calling the inc function
+    await call_contract_function("inc", server, keypair, contract);
+
+    // Check the incremented values
+    let sesa = await call_contract_function("sesa", server, keypair, contract);
+    expect(sesa.toString()).eq("2");
+
+    let sesa1 = await call_contract_function("sesa1", server, keypair, contract);
+    expect(sesa1.toString()).eq("2");
+
+    let sesa2 = await call_contract_function("sesa2", server, keypair, contract);
+    expect(sesa2.toString()).eq("3");
+
+    let sesa3 = await call_contract_function("sesa3", server, keypair, contract);
+    expect(sesa3.toString()).eq("3");
+  });
+
+  it('decrement values', async () => {
+    // Decrement all values by calling the dec function
+    await call_contract_function("dec", server, keypair, contract);
+
+    // Check the decremented values
+    let sesa = await call_contract_function("sesa", server, keypair, contract);
+    expect(sesa.toString()).eq("1");
+
+    let sesa1 = await call_contract_function("sesa1", server, keypair, contract);
+    expect(sesa1.toString()).eq("1");
+
+    let sesa2 = await call_contract_function("sesa2", server, keypair, contract);
+    expect(sesa2.toString()).eq("2");
+
+    let sesa3 = await call_contract_function("sesa3", server, keypair, contract);
+    expect(sesa3.toString()).eq("2");
+  });
+});

solang-parser/src/helpers/fmt.rs

@@ -4,7 +4,7 @@
 //!
 //! [ref]: https://docs.soliditylang.org/en/latest/style-guide.html
 
-use crate::pt;
+use crate::pt::{self, StorageType};
 use std::{
     borrow::Cow,
     fmt::{Display, Formatter, Result, Write},
@@ -1169,6 +1169,11 @@ impl Display for pt::VariableAttribute {
                 }
                 Ok(())
             }
+            Self::StorageType(storage) => match storage {
+                StorageType::Instance(_) => f.write_str("instance"),
+                StorageType::Temporary(_) => f.write_str("temporary"),
+                StorageType::Persistent(_) => f.write_str("persistent"),
+            },
         }
     }
 }

solang-parser/src/helpers/loc.rs

@@ -28,6 +28,14 @@ impl OptionalCodeLocation for pt::Visibility {
     }
 }
 
+impl OptionalCodeLocation for pt::StorageType {
+    fn loc_opt(&self) -> Option<Loc> {
+        match self {
+            Self::Persistent(l) | Self::Temporary(l) | Self::Instance(l) => *l,
+        }
+    }
+}
+
 impl OptionalCodeLocation for pt::SourceUnit {
     #[inline]
     fn loc_opt(&self) -> Option<Loc> {
@@ -431,6 +439,7 @@ impl_for_enums! {
 
     pt::VariableAttribute: match self {
         Self::Visibility(ref l, ..) => l.loc_opt().unwrap_or_default(),
+        Self::StorageType(ref l, ..) => l.loc_opt().unwrap_or_default(),
         Self::Constant(l, ..)
         | Self::Immutable(l, ..)
         | Self::Override(l, ..) => l,