Merge branch 'main' into fix/troubleshooting-emulator-tests

.github/workflows/bindings-ts.yml

@@ -0,0 +1,42 @@
+name: bindings typescript
+
+on:
+  push:
+    branches: [main, release/**]
+  pull_request:
+
+jobs:
+  test:
+    name: test generated libraries
+    runs-on: ubuntu-22.04
+    services:
+      rpc:
+        image: stellar/quickstart:testing
+        ports:
+          - 8000:8000
+        env:
+          ENABLE_LOGS: true
+          NETWORK: local
+          ENABLE_SOROBAN_RPC: true
+        options: >-
+          --health-cmd "curl --no-progress-meter --fail-with-body -X POST \"http://localhost:8000/soroban/rpc\" -H 'Content-Type: application/json' -d '{\"jsonrpc\":\"2.0\",\"id\":8675309,\"method\":\"getNetwork\"}' && curl --no-progress-meter \"http://localhost:8000/friendbot\" | grep '\"invalid_field\": \"addr\"'"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 50
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - run: rustup update
+      - run: cargo build
+      - run: rustup target add wasm32-unknown-unknown
+      - run: make build-test-wasms
+      - run: npm ci && npm run test
+        working-directory: cmd/crates/soroban-spec-typescript/ts-tests

cmd/crates/soroban-spec-typescript/ts-tests/package.json

@@ -14,7 +14,7 @@
     "ava": "^5.3.1",
     "dotenv": "^16.3.1",
     "eslint": "^8.53.0",
-    "@stellar/stellar-sdk": "12.1.0",
+    "@stellar/stellar-sdk": "12.2.0",
     "typescript": "^5.3.3"
   },
   "ava": {

cmd/crates/soroban-spec-typescript/ts-tests/src/util.ts

@@ -1,15 +1,22 @@
 import { spawnSync } from "node:child_process";
 import { Address, Keypair } from "@stellar/stellar-sdk";
-import { basicNodeSigner } from "@stellar/stellar-sdk/ContractClient";
+import { basicNodeSigner } from "@stellar/stellar-sdk/contract";
 
-const rootKeypair = Keypair.fromSecret(spawnSync("./soroban", ["keys", "show", "root"], { shell: true, encoding: "utf8" }).stdout.trim());
+const rootKeypair = Keypair.fromSecret(
+  spawnSync("./soroban", ["keys", "show", "root"], {
+    shell: true,
+    encoding: "utf8",
+  }).stdout.trim(),
+);
 
 export const root = {
   keypair: rootKeypair,
   address: Address.fromString(rootKeypair.publicKey()),
-}
+};
 
 export const rpcUrl = process.env.SOROBAN_RPC_URL ?? "http://localhost:8000/";
-export const networkPassphrase = process.env.SOROBAN_NETWORK_PASSPHRASE ?? "Standalone Network ; February 2017";
+export const networkPassphrase =
+  process.env.SOROBAN_NETWORK_PASSPHRASE ??
+  "Standalone Network ; February 2017";
 
 export const signer = basicNodeSigner(root.keypair, networkPassphrase);

cmd/crates/soroban-test/tests/it/integration.rs

@@ -1,6 +1,7 @@
 mod bindings;
 mod custom_types;
 mod dotenv;
+mod fund;
 mod hello_world;
 mod tx;
 mod util;

cmd/crates/soroban-test/tests/it/integration/fund.rs

@@ -0,0 +1,19 @@
+use soroban_test::TestEnv;
+
+#[tokio::test]
+#[allow(clippy::too_many_lines)]
+async fn fund() {
+    let sandbox = &TestEnv::new();
+    sandbox
+        .new_assert_cmd("keys")
+        .arg("generate")
+        .arg("test")
+        .assert()
+        .success();
+    sandbox
+        .new_assert_cmd("keys")
+        .arg("fund")
+        .arg("test")
+        .assert()
+        .stderr(predicates::str::contains("funding failed"));
+}

cmd/crates/soroban-test/tests/it/integration/hello_world.rs

@@ -32,12 +32,6 @@ async fn invoke() {
     let sandbox = &TestEnv::new();
     let c = soroban_rpc::Client::new(&sandbox.rpc_url).unwrap();
     let GetLatestLedgerResponse { sequence, .. } = c.get_latest_ledger().await.unwrap();
-    sandbox
-        .new_assert_cmd("keys")
-        .arg("fund")
-        .arg("test")
-        .assert()
-        .stderr(predicates::str::contains("Account already exists"));
     sandbox
         .new_assert_cmd("keys")
         .arg("fund")

cmd/soroban-cli/src/commands/contract/fetch.rs

@@ -6,12 +6,15 @@ use std::str::FromStr;
 use std::{fmt::Debug, fs, io};
 
 use clap::{arg, command, Parser};
+use stellar_xdr::curr::{ContractDataEntry, ContractExecutable, ScVal};
 
+use crate::commands::contract::fetch::Error::{ContractIsStellarAsset, UnexpectedContractToken};
 use crate::commands::{global, NetworkRunnable};
 use crate::config::{
     self, locator,
     network::{self, Network},
 };
+use crate::utils::rpc::get_remote_wasm_from_hash;
 use crate::{
     rpc::{self, Client},
     Pwd,
@@ -64,6 +67,13 @@ pub enum Error {
     Network(#[from] network::Error),
     #[error("cannot create contract directory for {0:?}")]
     CannotCreateContractDir(PathBuf),
+    #[error("unexpected contract data {0:?}")]
+    UnexpectedContractToken(ContractDataEntry),
+    #[error(
+        "cannot fetch wasm for contract because the contract is \
+    a network built-in asset contract that does not have a downloadable code binary"
+    )]
+    ContractIsStellarAsset(),
 }
 
 impl From<Infallible> for Error {
@@ -126,6 +136,15 @@ impl NetworkRunnable for Cmd {
         client
             .verify_network_passphrase(Some(&network.network_passphrase))
             .await?;
-        Ok(client.get_remote_wasm(&contract_id).await?)
+        let data_entry = client.get_contract_data(&contract_id).await?;
+        if let ScVal::ContractInstance(contract) = &data_entry.val {
+            return match &contract.executable {
+                ContractExecutable::Wasm(hash) => {
+                    Ok(get_remote_wasm_from_hash(&client, hash).await?)
+                }
+                ContractExecutable::StellarAsset => Err(ContractIsStellarAsset()),
+            };
+        }
+        return Err(UnexpectedContractToken(data_entry));
     }
 }

cmd/soroban-cli/src/config/network.rs

@@ -31,8 +31,8 @@ pub enum Error {
     FailedToParseJSON(String, serde_json::Error),
     #[error("Invalid URL {0}")]
     InvalidUrl(String),
-    #[error("Inproper response {0}")]
-    InproperResponse(String),
+    #[error("funding failed: {0}")]
+    FundingFailed(String),
 }
 
 #[derive(Debug, clap::Args, Clone, Default)]
@@ -149,16 +149,16 @@ impl Network {
                 return Err(Error::InvalidUrl(uri.to_string()));
             }
         };
+        let request_successful = response.status().is_success();
         let body = hyper::body::to_bytes(response.into_body()).await?;
         let res = serde_json::from_slice::<serde_json::Value>(&body)
             .map_err(|e| Error::FailedToParseJSON(uri.to_string(), e))?;
         tracing::debug!("{res:#?}");
-        if let Some(detail) = res.get("detail").and_then(Value::as_str) {
-            if detail.contains("createAccountAlreadyExist") {
-                eprintln!("Account already exists");
+        if !request_successful {
+            if let Some(detail) = res.get("detail").and_then(Value::as_str) {
+                return Err(Error::FundingFailed(detail.to_string()));
             }
-        } else if res.get("successful").is_none() {
-            return Err(Error::InproperResponse(res.to_string()));
+            return Err(Error::FundingFailed("unknown cause".to_string()));
         }
         Ok(())
     }

cmd/soroban-cli/src/get_spec.rs

@@ -10,6 +10,7 @@ pub use soroban_spec_tools::contract as contract_spec;
 use crate::commands::global;
 use crate::config::{self, data, locator, network};
 use crate::rpc;
+use crate::utils::rpc::get_remote_wasm_from_hash;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -65,7 +66,7 @@ pub async fn get_remote_contract_spec(
             if let Ok(entries) = data::read_spec(&hash_str) {
                 entries
             } else {
-                let raw_wasm = client.get_remote_wasm_from_hash(hash).await?;
+                let raw_wasm = get_remote_wasm_from_hash(&client, &hash).await?;
                 let res = contract_spec::Spec::new(&raw_wasm)?;
                 let res = res.spec;
                 if global_args.map_or(true, |a| !a.no_cache) {

cmd/soroban-cli/src/utils.rs

@@ -129,6 +129,29 @@ pub fn contract_id_hash_from_asset(
     Ok(Hash(Sha256::digest(preimage_xdr).into()))
 }
 
+pub mod rpc {
+    use soroban_env_host::xdr;
+    use soroban_rpc::{Client, Error};
+    use stellar_xdr::curr::{Hash, LedgerEntryData, LedgerKey, Limits, ReadXdr};
+
+    pub async fn get_remote_wasm_from_hash(client: &Client, hash: &Hash) -> Result<Vec<u8>, Error> {
+        let code_key = LedgerKey::ContractCode(xdr::LedgerKeyContractCode { hash: hash.clone() });
+        let contract_data = client.get_ledger_entries(&[code_key]).await?;
+        let entries = contract_data.entries.unwrap_or_default();
+        if entries.is_empty() {
+            return Err(Error::NotFound(
+                "Contract Code".to_string(),
+                hex::encode(hash),
+            ));
+        }
+        let contract_data_entry = &entries[0];
+        match LedgerEntryData::from_xdr_base64(&contract_data_entry.xdr, Limits::none())? {
+            LedgerEntryData::ContractCode(xdr::ContractCodeEntry { code, .. }) => Ok(code.into()),
+            scval => Err(Error::UnexpectedContractCodeDataType(scval)),
+        }
+    }
+}
+
 pub mod parsing {
 
     use regex::Regex;