assert on balances

Author: CAGS295

Cargo.toml

@@ -35,3 +35,4 @@ tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 url = "2.4.1"
 wsts = "1.2"
+blockstack-core = { git = "https://github.com/stacks-network/stacks-blockchain/", branch = "master" }

devenv/integration/bin/test

@@ -2,6 +2,7 @@
 set -ueo >/dev/null
 
 ENTRYPOINT_PATH="./integration/docker/entrypoint"
+CONFIG_PATH="./sbtc/docker/config.json"
 
 project_name() {
     local input="$1"
@@ -23,7 +24,7 @@ for filter in "${filters[@]}"; do
     ./integration/bin/up docker-compose.yml $project
 
     network=${project}_default
-    id=$(docker run -td --network $network -v $ENTRYPOINT_PATH:/usr/local/bin/entrypoint -e PROJECT_NAME=$project testbed "$filter")
+    id=$(docker run -td --network $network -v $ENTRYPOINT_PATH:/usr/local/bin/entrypoint -v $CONFIG_PATH:"/romeo/config.json" -e PROJECT_NAME=$project testbed "$filter")
     ids+=($id)
     echo with container id: $id
 

romeo/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 anyhow.workspace = true
 backoff = { workspace = true, features = ["tokio"] }
 bdk = { workspace = true, features = ["rpc", "esplora", "use-esplora-async"] }
-blockstack-core = { git = "https://github.com/stacks-network/stacks-blockchain/", branch = "master" }
+blockstack-core.workspace = true
 clap = { workspace = true, features = ["derive"] }
 derivative = { workspace = true }
 futures.workspace = true
@@ -27,3 +27,4 @@ rs_merkle.workspace = true
 [dev-dependencies]
 reqwest = { workspace = true, features = ["json", "blocking"] }
 sbtc-cli = { path = "../sbtc-cli" }
+stacks-core = { path = "../stacks-core", features = ["test-utils"] }

romeo/src/stacks_client.rs

@@ -12,6 +12,7 @@ use blockstack_lib::{
 	codec::StacksMessageCodec,
 	core::CHAIN_ID_TESTNET,
 	types::chainstate::StacksPrivateKey,
+	util::hash::bytes_to_hex,
 	vm::{
 		types::{QualifiedContractIdentifier, StandardPrincipalData},
 		ContractName,
@@ -21,7 +22,7 @@ use futures::Future;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use reqwest::{Request, RequestBuilder, Response, StatusCode};
 use serde::de::DeserializeOwned;
-use serde_json::Value;
+use serde_json::{json, Value};
 use stacks_core::{codec::Codec, uint::Uint256};
 use tokio::{
 	sync::{Mutex, MutexGuard},
@@ -463,6 +464,46 @@ impl StacksClient {
 	}
 }
 
+impl StacksClient {
+	/// Call read-only functions from smart contracts
+	pub async fn call_read_only_fn<R>(
+		&self,
+		contract: QualifiedContractIdentifier,
+		method: &str,
+		sender: &str,
+		args: Vec<blockstack_lib::vm::Value>,
+	) -> anyhow::Result<R>
+	where
+		R: DeserializeOwned,
+	{
+		Ok(self
+			.http_client
+			.post(
+				self.config
+					.stacks_node_url
+					.join(
+						format!(
+							"/v2/contracts/call-read/{}/{}/{}",
+							contract.issuer, contract.name, method
+						)
+						.as_str(),
+					)
+					.unwrap(),
+			)
+			.json(&json!({
+			"sender": sender,
+			"arguments": args
+							.iter()
+							.map(|a| bytes_to_hex(&a.serialize_to_vec()))
+							.collect::<Vec<_>>() }
+						))
+			.send()
+			.await?
+			.json()
+			.await?)
+	}
+}
+
 #[derive(serde::Deserialize)]
 struct NonceInfo {
 	possible_next_nonce: u64,

romeo/tests/tests/bitcoin_client.rs

@@ -1,15 +1,27 @@
-use std::{str::FromStr, thread::sleep, time::Duration};
+use std::{io::Cursor, str::FromStr, thread::sleep, time::Duration};
 
 use bdk::{
 	bitcoin::{hash_types::Txid, Address, BlockHash},
 	bitcoincore_rpc::{Auth, Client as BClient, RpcApi},
 };
+use blockstack_lib::{
+	codec::StacksMessageCodec,
+	types::chainstate::StacksAddress,
+	util::hash::hex_bytes,
+	vm::{
+		types::{QualifiedContractIdentifier, StandardPrincipalData},
+		ContractName, Value,
+	},
+};
+use romeo::stacks_client::StacksClient;
 use url::Url;
 
+/// devenv's service url
 pub fn bitcoin_url() -> Url {
 	Url::parse("http://bitcoin:18443").unwrap()
 }
 
+/// devenv's service url
 pub fn electrs_url() -> Url {
 	Url::parse("tcp://electrs:60401").unwrap()
 }
@@ -49,3 +61,35 @@ pub fn wait_for_tx_confirmation(
 		sleep(Duration::from_secs(1));
 	}
 }
+
+pub async fn sbtc_balance(
+	stacks_client: &StacksClient,
+	deployer_address: StacksAddress,
+	recipient_address: StacksAddress,
+	contract_name: ContractName,
+) -> u128 {
+	let res: serde_json::Value = stacks_client
+		.call_read_only_fn(
+			QualifiedContractIdentifier::new(
+				StandardPrincipalData::from(deployer_address),
+				contract_name,
+			),
+			"get-balance",
+			recipient_address.to_string().as_str(),
+			vec![StandardPrincipalData::from(recipient_address).into()],
+		)
+		.await
+		.unwrap();
+
+	assert!(res["okay"].as_bool().unwrap());
+	// request token balance from the asset contract.
+	let bytes =
+		hex_bytes(res["result"].as_str().unwrap().trim_start_matches("0x"))
+			.unwrap();
+
+	let mut cursor = Cursor::new(&bytes);
+	Value::consensus_deserialize(&mut cursor)
+		.unwrap()
+		.expect_result_ok()
+		.expect_u128()
+}

romeo/tests/tests/deposit.rs

@@ -1,4 +1,4 @@
-use std::{str::FromStr, thread::sleep, time::Duration};
+use std::{str::FromStr, time::Duration};
 
 use anyhow::Result;
 use bdk::{
@@ -11,22 +11,25 @@ use bdk::{
 	template::P2Wpkh,
 	SyncOptions, Wallet,
 };
+use romeo::{config::Config, stacks_client::StacksClient};
 use sbtc_cli::commands::{
 	broadcast::{broadcast_tx, BroadcastArgs},
 	deposit::{build_deposit_tx, DepositArgs},
 };
+use stacks_core::address::StacksAddress;
+use tokio::time::sleep;
 
 use super::{
 	bitcoin_client::{
-		bitcoin_url, client_new, electrs_url, mine_blocks,
+		bitcoin_url, client_new, electrs_url, mine_blocks, sbtc_balance,
 		wait_for_tx_confirmation,
 	},
-	KeyType::*,
+	KeyType::{self, *},
 	WALLETS,
 };
 
-#[test]
-fn broadcast_deposit() -> Result<()> {
+#[tokio::test]
+async fn broadcast_deposit() -> Result<()> {
 	let b_client = client_new(bitcoin_url().as_str(), "devnet", "devnet");
 
 	b_client
@@ -46,8 +49,6 @@ fn broadcast_deposit() -> Result<()> {
 
 	let electrum_url = electrs_url();
 
-	// suboptimal, replace once we have better events.
-	// replace with b_client balance?
 	{
 		let blockchain =
 			ElectrumBlockchain::from_config(&ElectrumBlockchainConfig {
@@ -76,34 +77,74 @@ fn broadcast_deposit() -> Result<()> {
 			if balance.confirmed != 0 {
 				break;
 			}
-			sleep(Duration::from_millis(1_000));
+			sleep(Duration::from_millis(1_000)).await;
 		}
 	}
 
 	let amount = 10_000;
+	let deployer_stacks_address = WALLETS[0][KeyType::Stacks].address;
+	let recipient_stacks_address = WALLETS[1][KeyType::Stacks].address;
 
 	let tx = {
 		let args = DepositArgs {
 			node_url: electrum_url.clone(),
 			wif: WALLETS[1][P2wpkh].wif.into(),
 			network: bdk::bitcoin::Network::Regtest,
-			recipient: WALLETS[1][Stacks].address.into(),
+			recipient: recipient_stacks_address.into(),
 			amount,
 			sbtc_wallet: WALLETS[0][P2tr].address.into(),
 		};
 
 		build_deposit_tx(&args).unwrap()
 	};
 
-	broadcast_tx(&BroadcastArgs {
-		node_url: electrum_url,
-		tx: hex::encode(tx.serialize()),
-	})
-	.unwrap();
+	let config = Config::from_path("config.json").unwrap();
 
-	let txid = tx.txid();
+	// make sure config urls match devenv.
+	let stacks_client =
+		StacksClient::new(config.clone(), reqwest::Client::new());
 
-	wait_for_tx_confirmation(&b_client, &txid, 1);
+	let deployer_address =
+		StacksAddress::transmute_stacks_address(deployer_stacks_address);
+	let recipient_address =
+		StacksAddress::transmute_stacks_address(recipient_stacks_address);
+
+	// prior balance
+	assert_eq!(
+		sbtc_balance(
+			&stacks_client,
+			deployer_address,
+			recipient_address,
+			config.contract_name.clone()
+		)
+		.await,
+		0
+	);
+
+	// Sign, send and wait for confirmation.
+	{
+		broadcast_tx(&BroadcastArgs {
+			node_url: electrum_url,
+			tx: hex::encode(tx.serialize()),
+		})
+		.unwrap();
+
+		let txid = tx.txid();
+
+		wait_for_tx_confirmation(&b_client, &txid, 1);
+	}
+
+	// assert on new sbtc token balance
+	while sbtc_balance(
+		&stacks_client,
+		deployer_address,
+		recipient_address,
+		config.contract_name.clone(),
+	)
+	.await != amount as u128
+	{
+		sleep(Duration::from_secs(2)).await
+	}
 
 	Ok(())
 }

romeo/tests/tests/stacks_client.rs

@@ -1,6 +1,7 @@
 use reqwest::blocking::Client;
 use url::Url;
 
+/// devenv's service url
 pub fn stacks_url() -> Url {
 	Url::parse("http://stacks:20443").unwrap()
 }

sbtc-cli/src/main.rs

@@ -7,7 +7,7 @@
 //! and interact with the Bitcoin and Stacks networks.
 use std::io::stdout;
 
-use bdk::bitcoin::psbt::serialize::Serialize;
+use bdk::bitcoin::{psbt::serialize::Serialize, Transaction};
 use clap::{Parser, Subcommand};
 use sbtc_cli::commands::{
 	broadcast::{broadcast_tx, BroadcastArgs},
@@ -31,19 +31,23 @@ enum Command {
 	GenerateFrom(GenerateArgs),
 }
 
+fn to_stdout_pretty(txn: Transaction) -> serde_json::Result<()> {
+	serde_json::to_writer_pretty(
+		stdout(),
+		&utils::TransactionData {
+			id: txn.txid().to_string(),
+			hex: hex::encode(txn.serialize()),
+		},
+	)
+}
+
 fn main() -> Result<(), anyhow::Error> {
 	let args = Cli::parse();
 
 	match args.command {
 		Command::Deposit(deposit_args) => build_deposit_tx(&deposit_args)
 			.and_then(|t| {
-				serde_json::to_writer_pretty(
-					stdout(),
-					&utils::TransactionData {
-						id: t.txid().to_string(),
-						hex: hex::encode(t.serialize()),
-					},
-				)?;
+				to_stdout_pretty(t)?;
 				Ok(())
 			}),
 		Command::Withdraw(withdrawal_args) => {

stacks-core/Cargo.toml

@@ -27,7 +27,11 @@ serde = { workspace = true, features = ["derive"] }
 sha2.workspace = true
 strum = { workspace = true, features = ["derive"] }
 thiserror.workspace = true
+blockstack-core.workspace = true
 
 [dev-dependencies]
 hex.workspace = true
 rand.workspace = true
+
+[features]
+test-utils = []

stacks-core/src/address.rs

@@ -6,6 +6,10 @@ use std::{
 use bdk::bitcoin::blockdata::{
 	opcodes::all::OP_CHECKMULTISIG, script::Builder,
 };
+use blockstack_lib::{
+	codec::StacksMessageCodec,
+	types::chainstate::StacksAddress as CStacksAddress,
+};
 use serde::Serialize;
 use strum::{EnumIter, FromRepr};
 
@@ -100,6 +104,16 @@ impl StacksAddress {
 	pub fn from_public_key(version: AddressVersion, key: &PublicKey) -> Self {
 		Self::p2pkh(version, key)
 	}
+
+	/// Transmute to stacks-blockchain type
+	pub fn into_native_stacks_address(self) -> CStacksAddress {
+		use std::io::Cursor;
+
+		CStacksAddress::consensus_deserialize(&mut Cursor::new(
+			self.serialize_to_vec(),
+		))
+		.unwrap()
+	}
 }
 
 impl Codec for StacksAddress {
@@ -226,6 +240,16 @@ fn hash_p2wsh<'a>(
 	Hash160Hasher::new(&buff)
 }
 
+#[cfg(feature = "test-utils")]
+impl StacksAddress {
+	/// copy StacksAddress as a native stacks-blockchain address type
+	pub fn transmute_stacks_address(address: &str) -> CStacksAddress {
+		StacksAddress::try_from(address)
+			.unwrap()
+			.into_native_stacks_address()
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;