+where
+ P: Provider + Clone,
+{
+ let deployed = DexRouterMock::deploy(provider, permit2)
+ .await
+ .context("failed to deploy DexRouterMock")?;
+
+ Ok(*deployed.address())
+}
diff --git a/crates/integration-test/src/deploy/forwarder.rs b/crates/integration-test/src/deploy/forwarder.rs
new file mode 100644
index 0000000..7326624
--- /dev/null
+++ b/crates/integration-test/src/deploy/forwarder.rs
@@ -0,0 +1,49 @@
+use alloy::primitives::Address;
+use alloy::primitives::B256;
+use alloy::providers::Provider;
+use anoma_generic_call_forwarder_bindings::generated::generic_call_forwarder::GenericCallForwarder;
+use anyhow::Context;
+
+use crate::state::addresses::insert_generic_call_forwarder_v1_address;
+
+#[inline]
+pub fn generic_call_forwarder(
+ address: Address,
+ provider: P,
+) -> GenericCallForwarder::GenericCallForwarderInstance
+where
+ P: Provider,
+{
+ GenericCallForwarder::GenericCallForwarderInstance::new(address, provider)
+}
+
+pub async fn deploy_generic_call_forwarder
(
+ provider: P,
+ protocol_adapter: Address,
+ logic_ref: B256,
+) -> anyhow::Result
+where
+ P: Provider + Clone,
+{
+ let deployed = GenericCallForwarder::deploy(provider, protocol_adapter, logic_ref)
+ .await
+ .context("failed to deploy GenericCallForwarder")?;
+
+ Ok(*deployed.address())
+}
+
+pub async fn deploy_and_insert_generic_call_forwarder(
+ builder: &mut anoma_pa_testkit::environment::StateBuilder,
+ provider: P,
+ protocol_adapter: Address,
+ logic_ref: B256,
+) -> anyhow::Result
+where
+ P: Provider + Clone,
+{
+ let address = deploy_generic_call_forwarder(provider, protocol_adapter, logic_ref).await?;
+
+ insert_generic_call_forwarder_v1_address(builder, address);
+
+ Ok(address)
+}
diff --git a/crates/integration-test/src/deploy/mod.rs b/crates/integration-test/src/deploy/mod.rs
new file mode 100644
index 0000000..13895d6
--- /dev/null
+++ b/crates/integration-test/src/deploy/mod.rs
@@ -0,0 +1,4 @@
+//! Generic call forwarder deploy bindings.
+
+pub mod dex_router;
+pub mod forwarder;
diff --git a/crates/integration-test/src/fixtures/generic_call/action.rs b/crates/integration-test/src/fixtures/generic_call/action.rs
new file mode 100644
index 0000000..d0eff39
--- /dev/null
+++ b/crates/integration-test/src/fixtures/generic_call/action.rs
@@ -0,0 +1,90 @@
+use anoma_generic_call_library::GenericCall;
+use anoma_generic_call_library::GenericCallLogic;
+use anoma_pa_testkit::witness::ActionWitnesses;
+use anoma_rm_risc0::action_tree::MerkleTree as ArmTree;
+use anoma_rm_risc0::compliance::ComplianceWitness;
+use anoma_rm_risc0::resource::Resource;
+use anyhow::Context;
+
+use super::resource;
+use super::resource::Overrides;
+use crate::logic;
+
+/// The derived data of a built generic-call action: the action witnesses
+/// plus the ephemeral resources it consumes and creates.
+pub struct ActionData {
+ pub witnesses: ActionWitnesses,
+ pub consumed_ephemeral: Resource,
+ pub created_ephemeral: Resource,
+}
+
+/// Build a generic-call action: consumes an ephemeral resource whose label
+/// commits to the forwarder `calls` and creates an ephemeral resource carrying
+/// no calls.
+pub fn build(
+ seed: u8,
+ forwarder_addr: Vec,
+ calls: Vec,
+ overrides: Overrides,
+) -> anyhow::Result {
+ let created_calls: Vec = Vec::new();
+
+ let nf_key = resource::nullifier_key(seed);
+ let nk_commitment = nf_key.commit();
+
+ let consumed_ephemeral =
+ resource::consumed(seed, nk_commitment, &forwarder_addr, &calls, &overrides)?;
+ let consumed_nullifier = consumed_ephemeral
+ .nullifier(&nf_key)
+ .context("failed to compute consumed nullifier")?;
+ let created_ephemeral = resource::created(
+ seed,
+ nk_commitment,
+ consumed_nullifier,
+ &forwarder_addr,
+ &created_calls,
+ &overrides,
+ )?;
+
+ let compliance_witness = ComplianceWitness::from_resources(
+ consumed_ephemeral,
+ *anoma_rm_risc0::compliance::INITIAL_ROOT,
+ nf_key.clone(),
+ created_ephemeral,
+ );
+
+ let action_tree_root = ArmTree::new(vec![consumed_nullifier, created_ephemeral.commitment()])
+ .root()
+ .context("failed to compute action tree root")?;
+
+ let consumed_logic_witness = GenericCallLogic::consumed_ephemeral_resource_logic(
+ consumed_ephemeral,
+ action_tree_root,
+ nf_key,
+ forwarder_addr.clone(),
+ calls.clone(),
+ )
+ .witness;
+
+ let created_logic_witness = GenericCallLogic::created_ephemeral_resource_logic(
+ created_ephemeral,
+ action_tree_root,
+ forwarder_addr,
+ created_calls,
+ )
+ .witness;
+
+ let witnesses = ActionWitnesses {
+ compliance_witnesses: vec![Box::new(compliance_witness)],
+ logic_witnesses: vec![
+ Box::new(logic::Witness::new(consumed_logic_witness)),
+ Box::new(logic::Witness::new(created_logic_witness)),
+ ],
+ };
+
+ Ok(ActionData {
+ witnesses,
+ consumed_ephemeral,
+ created_ephemeral,
+ })
+}
diff --git a/crates/integration-test/src/fixtures/generic_call/mod.rs b/crates/integration-test/src/fixtures/generic_call/mod.rs
new file mode 100644
index 0000000..4d8fded
--- /dev/null
+++ b/crates/integration-test/src/fixtures/generic_call/mod.rs
@@ -0,0 +1,9 @@
+//! Generic-call action: consumes an ephemeral resource carrying the forwarder
+//! calls and creates an ephemeral resource, driving arbitrary calls through the
+//! generic-call forwarder.
+
+mod action;
+mod resource;
+
+pub use action::{ActionData, build};
+pub use resource::Overrides;
diff --git a/crates/integration-test/src/fixtures/generic_call/resource.rs b/crates/integration-test/src/fixtures/generic_call/resource.rs
new file mode 100644
index 0000000..e22401b
--- /dev/null
+++ b/crates/integration-test/src/fixtures/generic_call/resource.rs
@@ -0,0 +1,118 @@
+use anoma_generic_call_witness::GenericCall;
+use anoma_generic_call_witness::calculate_label_ref;
+use anoma_generic_call_witness::calculate_value_ref;
+use anoma_generic_call_witness::encode_generic_call_forwarder_input;
+use anoma_rm_risc0::Digest;
+use anoma_rm_risc0::nullifier_key::NullifierKey;
+use anoma_rm_risc0::nullifier_key::NullifierKeyCommitment;
+use anoma_rm_risc0::resource::Resource;
+use anyhow::Context;
+
+use crate::logic;
+
+#[derive(Clone, Debug, Default)]
+pub struct Overrides {
+ pub consumed_quantity: Option,
+ pub created_quantity: Option,
+ pub consumed_value_ref: Option,
+ pub created_value_ref: Option,
+ pub consumed_label_ref: Option,
+ pub created_label_ref: Option,
+ pub consumed_is_ephemeral: Option,
+ pub created_is_ephemeral: Option,
+ pub consumed_nonce: Option<[u8; 32]>,
+ pub created_nonce: Option<[u8; 32]>,
+}
+
+impl Overrides {
+ pub fn invalid_consumed_non_ephemeral() -> Self {
+ Self {
+ consumed_is_ephemeral: Some(false),
+ ..Self::default()
+ }
+ }
+
+ pub fn invalid_created_non_ephemeral() -> Self {
+ Self {
+ created_is_ephemeral: Some(false),
+ ..Self::default()
+ }
+ }
+
+ pub fn invalid_consumed_label_ref() -> Self {
+ Self {
+ consumed_label_ref: Some(Digest::default()),
+ ..Self::default()
+ }
+ }
+}
+
+pub(super) fn consumed(
+ seed: u8,
+ nk_commitment: NullifierKeyCommitment,
+ forwarder_addr: &[u8],
+ calls: &[GenericCall],
+ overrides: &Overrides,
+) -> anyhow::Result {
+ let encoded_calls =
+ encode_generic_call_forwarder_input(calls).context("failed to encode generic calls")?;
+
+ let value_ref = overrides
+ .consumed_value_ref
+ .unwrap_or(calculate_value_ref(&encoded_calls));
+
+ let label_ref = overrides
+ .consumed_label_ref
+ .unwrap_or(calculate_label_ref(forwarder_addr));
+
+ Ok(Resource {
+ logic_ref: logic::verifying_key(),
+ label_ref,
+ quantity: overrides.consumed_quantity.unwrap_or(0),
+ value_ref,
+ is_ephemeral: overrides.consumed_is_ephemeral.unwrap_or(true),
+ nonce: overrides.consumed_nonce.unwrap_or([seed; 32]),
+ nk_commitment,
+ rand_seed: [seed.wrapping_add(11); 32],
+ })
+}
+
+pub(super) fn created(
+ seed: u8,
+ nk_commitment: NullifierKeyCommitment,
+ consumed_nullifier: Digest,
+ forwarder_addr: &[u8],
+ calls: &[GenericCall],
+ overrides: &Overrides,
+) -> anyhow::Result {
+ let encoded_calls =
+ encode_generic_call_forwarder_input(calls).context("failed to encode generic calls")?;
+
+ let value_ref = overrides
+ .created_value_ref
+ .unwrap_or(calculate_value_ref(&encoded_calls));
+
+ let label_ref = overrides
+ .created_label_ref
+ .unwrap_or(calculate_label_ref(forwarder_addr));
+
+ let default_nonce: [u8; 32] = consumed_nullifier
+ .as_bytes()
+ .try_into()
+ .context("nullifier must be 32 bytes")?;
+
+ Ok(Resource {
+ logic_ref: logic::verifying_key(),
+ label_ref,
+ quantity: overrides.created_quantity.unwrap_or(0),
+ value_ref,
+ is_ephemeral: overrides.created_is_ephemeral.unwrap_or(true),
+ nonce: overrides.created_nonce.unwrap_or(default_nonce),
+ nk_commitment,
+ rand_seed: [seed.wrapping_add(33); 32],
+ })
+}
+
+pub(super) fn nullifier_key(seed: u8) -> NullifierKey {
+ NullifierKey::from_bytes([seed; 32])
+}
diff --git a/crates/integration-test/src/fixtures/mod.rs b/crates/integration-test/src/fixtures/mod.rs
new file mode 100644
index 0000000..c67f6c2
--- /dev/null
+++ b/crates/integration-test/src/fixtures/mod.rs
@@ -0,0 +1,7 @@
+//! Generic-call action fixtures. The single [`generic_call`] kind exposes the
+//! single-builder surface of testkit ADR-0003 — `build`, the derived-data
+//! bundle `ActionData`, and `Overrides` with named `invalid_*` variants for negative
+//! tests. The shared resource logic (verifying key + witness adapter) lives in
+//! [`crate::logic`].
+
+pub mod generic_call;
diff --git a/crates/integration-test/src/lib.rs b/crates/integration-test/src/lib.rs
new file mode 100644
index 0000000..b221e6e
--- /dev/null
+++ b/crates/integration-test/src/lib.rs
@@ -0,0 +1,10 @@
+//! Integration-test harness for the Anoma generic call forwarder.
+//!
+//! Exposes the generic-call provisioning helpers (`deploy`, `state`), the
+//! resource `logic` (verifying key + witness adapter), and the action `fixtures`.
+//! Scenario setups and the scenarios live under `tests/`.
+
+pub mod deploy;
+pub mod fixtures;
+pub mod logic;
+pub mod state;
diff --git a/crates/integration-test/src/logic.rs b/crates/integration-test/src/logic.rs
new file mode 100644
index 0000000..c70d17a
--- /dev/null
+++ b/crates/integration-test/src/logic.rs
@@ -0,0 +1,51 @@
+//! The generic-call resource logic: its verifying key and the [`LogicWitness`]
+//! adapter over [`GenericCallWitness`] that the generic-call action feeds to the
+//! prover.
+
+use anoma_generic_call_library::GenericCallLogic;
+use anoma_generic_call_witness::GenericCallWitness;
+use anoma_pa_testkit::witness::LogicWitness;
+use anoma_rm_risc0::Digest;
+use anoma_rm_risc0::logic_instance::LogicInstance;
+use anoma_rm_risc0::logic_proof::LogicProver;
+use anoma_rm_risc0::resource_logic::LogicCircuit;
+use anyhow::Context;
+
+/// Verifying key (image id) of the generic-call resource logic.
+#[inline]
+pub fn verifying_key() -> Digest {
+ GenericCallLogic::verifying_key()
+}
+
+/// Adapts a [`GenericCallWitness`] to the testkit's [`LogicWitness`] trait.
+pub(crate) struct Witness {
+ inner: GenericCallWitness,
+}
+
+impl Witness {
+ #[inline]
+ pub(crate) fn new(inner: GenericCallWitness) -> Self {
+ Self { inner }
+ }
+}
+
+impl LogicWitness for Witness {
+ fn verifying_key(&self) -> Digest {
+ verifying_key()
+ }
+
+ fn constrain(&self) -> anyhow::Result {
+ LogicCircuit::constrain(&self.inner)
+ .map_err(anyhow::Error::from)
+ .context("invalid generic call logic witness")
+ }
+
+ fn witness_to_vec(&self) -> anyhow::Result> {
+ risc0_zkvm::serde::to_vec(&self.inner)
+ .context("failed to serialize generic call logic witness to risc0 words")
+ }
+
+ fn proving_key(&self) -> Vec {
+ GenericCallLogic::proving_key().to_vec()
+ }
+}
diff --git a/crates/integration-test/src/state/addresses.rs b/crates/integration-test/src/state/addresses.rs
new file mode 100644
index 0000000..4f309b3
--- /dev/null
+++ b/crates/integration-test/src/state/addresses.rs
@@ -0,0 +1,69 @@
+use alloy::primitives::Address;
+use anoma_pa_testkit::environment::Environment;
+use anoma_pa_testkit::environment::State;
+use anoma_pa_testkit::environment::StateBuilder;
+use anyhow::Context;
+
+use super::keys::generic_call_forwarder_v1_addr_key;
+
+#[inline]
+pub fn insert_generic_call_forwarder_v1_address(builder: &mut StateBuilder, address: Address) {
+ builder.insert(generic_call_forwarder_v1_addr_key(), address);
+}
+
+#[inline]
+pub fn generic_call_forwarder_v1_address(env: &E) -> anyhow::Result
+where
+ E: Environment,
+{
+ generic_call_forwarder_v1_address_in_state(env.state())
+}
+
+#[inline]
+pub fn generic_call_forwarder_v1_address_in_state(state: &State) -> anyhow::Result {
+ state
+ .get::(generic_call_forwarder_v1_addr_key())
+ .copied()
+ .context("failed to retrieve generic call forwarder v1 address from env")
+}
+
+#[cfg(test)]
+mod tests {
+ use anoma_pa_testkit::mocks::MockEnvironment;
+
+ use super::*;
+
+ #[test]
+ fn insert_and_resolve_generic_call_forwarder_v1_address() {
+ let expected = Address::from([0x41; 20]);
+
+ let state = {
+ let mut builder = StateBuilder::new();
+ insert_generic_call_forwarder_v1_address(&mut builder, expected);
+ builder.finalize()
+ };
+
+ let mut env = MockEnvironment::new();
+ env.expect_state().return_const(state);
+
+ let resolved = generic_call_forwarder_v1_address(&env)
+ .expect("must resolve stored generic call forwarder address");
+ assert_eq!(resolved, expected);
+ }
+
+ #[test]
+ fn missing_generic_call_forwarder_v1_address_errors() {
+ let state = StateBuilder::new().finalize();
+
+ let mut env = MockEnvironment::new();
+ env.expect_state().return_const(state);
+
+ let err = generic_call_forwarder_v1_address(&env)
+ .expect_err("must fail on missing generic call forwarder address key");
+ assert!(
+ err.to_string()
+ .contains("failed to retrieve generic call forwarder v1 address from env"),
+ "error should mention missing generic call forwarder address, got: {err}"
+ );
+ }
+}
diff --git a/crates/integration-test/src/state/keys.rs b/crates/integration-test/src/state/keys.rs
new file mode 100644
index 0000000..27d5461
--- /dev/null
+++ b/crates/integration-test/src/state/keys.rs
@@ -0,0 +1,19 @@
+pub const KEY_GENERIC_CALL_FORWARDER_V1_ADDRESS: &str = "evm.forwarder.generic-call.v1";
+
+#[inline]
+pub fn generic_call_forwarder_v1_addr_key() -> &'static str {
+ KEY_GENERIC_CALL_FORWARDER_V1_ADDRESS
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn generic_call_forwarder_v1_key_format() {
+ assert_eq!(
+ generic_call_forwarder_v1_addr_key(),
+ "evm.forwarder.generic-call.v1"
+ );
+ }
+}
diff --git a/crates/integration-test/src/state/mod.rs b/crates/integration-test/src/state/mod.rs
new file mode 100644
index 0000000..9ed0f39
--- /dev/null
+++ b/crates/integration-test/src/state/mod.rs
@@ -0,0 +1,2 @@
+pub mod addresses;
+pub mod keys;
diff --git a/crates/integration-test/tests/common/mod.rs b/crates/integration-test/tests/common/mod.rs
new file mode 100644
index 0000000..156cf11
--- /dev/null
+++ b/crates/integration-test/tests/common/mod.rs
@@ -0,0 +1,102 @@
+//! Shared scenario setups for the generic-call integration tests.
+//!
+//! This lives under `tests/` so it is purely test code: it is never compiled
+//! into a library and is invisible to dependents. Each integration test
+//! includes it with `mod common;`. Reusable helpers (assertions, provisioning)
+//! live in the testkit and the integration-test crates instead.
+
+#[cfg(feature = "e2e")]
+pub type EvmE2eEnv = anoma_pa_evm_integration_test::envs::e2e::Environment;
+
+pub type EvmLocalEnv = anoma_pa_evm_integration_test::envs::local::Environment;
+
+use alloy::primitives::{B256, U256};
+use anoma_generic_call_forwarder_integration_test::deploy::forwarder::deploy_and_insert_generic_call_forwarder;
+use anoma_generic_call_forwarder_integration_test::logic as generic_call_logic;
+use anoma_pa_evm_integration_test::keychain::EvmSigner;
+use anoma_pa_evm_integration_test::state::actors::default_signer_in_state;
+use anoma_pa_evm_integration_test::state::pa::pa_address_in_state;
+use anoma_pa_testkit::environment::StateBuilder;
+use anoma_pa_testkit::fixtures::identities;
+use anomapay_erc20_forwarder_integration_test::deploy::erc20::ierc20_bindings::ierc20;
+use anomapay_erc20_forwarder_integration_test::deploy::erc20::weth_bindings::deploy_and_insert_weth;
+use anomapay_erc20_forwarder_integration_test::deploy::forwarder::deploy_and_insert_erc20_forwarder;
+use anomapay_erc20_forwarder_integration_test::deploy::permit2::PERMIT2_CANONICAL_ADDRESS;
+use anomapay_erc20_forwarder_integration_test::deploy::permit2::deploy_permit2_canonical_from_state;
+use anomapay_erc20_forwarder_integration_test::logic as erc20_logic;
+use anyhow::Context;
+
+pub use anoma_pa_testkit::{commitment_root, execute_tx, prove_actions};
+
+pub async fn setup_transfer_generic_call_local_env() -> anyhow::Result {
+ EvmLocalEnv::setup(async |builder: &mut StateBuilder| {
+ deploy_permit2_canonical_from_state(builder.as_state())
+ .await
+ .context("failed to deploy Permit2 at canonical address")?;
+ setup_transfer_generic_call_env_on_builder(builder).await
+ })
+ .await
+}
+
+#[cfg(feature = "e2e")]
+pub async fn setup_transfer_generic_call_e2e_env() -> anyhow::Result {
+ EvmE2eEnv::setup(async |builder: &mut StateBuilder| {
+ setup_transfer_generic_call_env_on_builder(builder).await
+ })
+ .await
+}
+
+async fn setup_transfer_generic_call_env_on_builder(
+ builder: &mut StateBuilder,
+) -> anyhow::Result<()> {
+ let provider = default_signer_in_state(builder.as_state())
+ .context("failed to retrieve default signer from setup state")?;
+ let pa_address = pa_address_in_state(builder.as_state())
+ .context("failed to retrieve protocol adapter address from setup state")?;
+
+ let deployer = identities::alice()
+ .context("failed to build sender keychain")?
+ .address();
+
+ let token = deploy_and_insert_weth(
+ builder,
+ "weth",
+ provider.clone(),
+ deployer,
+ U256::from(1_000_000u64),
+ )
+ .await
+ .context("failed to deploy and insert WETH9")?;
+
+ let transfer_logic_ref = B256::from(<[u8; 32]>::from(erc20_logic::verifying_key()));
+ deploy_and_insert_erc20_forwarder(
+ builder,
+ provider.clone(),
+ pa_address,
+ transfer_logic_ref,
+ deployer,
+ )
+ .await
+ .context("failed to deploy and insert ERC20 forwarder v1")?;
+
+ let generic_call_logic_ref = B256::from(<[u8; 32]>::from(generic_call_logic::verifying_key()));
+ deploy_and_insert_generic_call_forwarder(
+ builder,
+ provider.clone(),
+ pa_address,
+ generic_call_logic_ref,
+ )
+ .await
+ .context("failed to deploy and insert generic call forwarder v1")?;
+
+ ierc20(token, provider.clone())
+ .approve(PERMIT2_CANONICAL_ADDRESS, U256::MAX)
+ .send()
+ .await
+ .context("failed to submit WETH permit2 approval transaction")?
+ .get_receipt()
+ .await
+ .context("failed to fetch WETH permit2 approval receipt")?;
+
+ Ok(())
+}
diff --git a/crates/integration-test/tests/generic_call_action.rs b/crates/integration-test/tests/generic_call_action.rs
new file mode 100644
index 0000000..e453ec6
--- /dev/null
+++ b/crates/integration-test/tests/generic_call_action.rs
@@ -0,0 +1,50 @@
+//! Chain-free smoke tests for the generic-call action fixtures: the builder
+//! produces a well-formed action (one compliance unit) for valid and
+//! deliberately-invalid override variants. No prover or chain is needed.
+
+use anoma_generic_call_forwarder_integration_test::fixtures::generic_call;
+use anoma_generic_call_witness::GenericCall;
+
+fn sample_calls() -> Vec {
+ vec![GenericCall {
+ to: vec![0x11; 20],
+ value: 7,
+ data: vec![0xaa, 0xbb],
+ }]
+}
+
+#[test]
+fn build_produces_single_compliance_unit() {
+ let built = generic_call::build(
+ 1,
+ vec![0x22; 20],
+ sample_calls(),
+ generic_call::Overrides::default(),
+ )
+ .expect("must build");
+ assert_eq!(built.witnesses.compliance_witnesses.len(), 1);
+}
+
+#[test]
+fn build_with_invalid_consumed_non_ephemeral_still_builds() {
+ let built = generic_call::build(
+ 2,
+ vec![0x33; 20],
+ sample_calls(),
+ generic_call::Overrides::invalid_consumed_non_ephemeral(),
+ )
+ .expect("must build invalid action");
+ assert_eq!(built.witnesses.compliance_witnesses.len(), 1);
+}
+
+#[test]
+fn build_with_invalid_consumed_label_ref_still_builds() {
+ let built = generic_call::build(
+ 3,
+ vec![0x44; 20],
+ sample_calls(),
+ generic_call::Overrides::invalid_consumed_label_ref(),
+ )
+ .expect("must build invalid action");
+ assert_eq!(built.witnesses.compliance_witnesses.len(), 1);
+}
diff --git a/crates/integration-test/tests/swap_erc20s_on_a_dex.rs b/crates/integration-test/tests/swap_erc20s_on_a_dex.rs
new file mode 100644
index 0000000..ca3c9b6
--- /dev/null
+++ b/crates/integration-test/tests/swap_erc20s_on_a_dex.rs
@@ -0,0 +1,311 @@
+//! Demonstrates a DEX swap routed through the generic-call forwarder: an ERC20
+//! resource of token A is unwrapped into the generic-call forwarder, swapped on
+//! a (mock) Uniswap-style router for token B, and wrapped back into a resource.
+//!
+//! Mirrors the Solidity `test_calls_allow_swapping_fund_on_a_dex` in
+//! `contracts/test/GenericCallForwarder.t.sol`, but as a full integration test:
+//! every step is a risc0-proven transaction executed against a local chain.
+
+use alloy::primitives::aliases::{U48, U160};
+use alloy::primitives::{Address, U256};
+use alloy::sol;
+use alloy::sol_types::SolCall;
+use anoma_generic_call_forwarder_integration_test as it;
+use anoma_pa_evm_integration_test::state::actors::default_signer;
+
+mod common;
+use anoma_pa_evm_integration_test::keychain::EvmSigner;
+use anoma_pa_evm_integration_test::state::chains::chain_id;
+use anoma_pa_testkit::environment::CommitmentTree;
+use anoma_pa_testkit::environment::Environment;
+use anoma_pa_testkit::environment::ProtocolAdapter;
+use anoma_pa_testkit::fixtures::identities;
+use anomapay_erc20_forwarder_integration_test::deploy::erc20::example_erc20_bindings::{
+ deploy_and_mint_example_erc20, erc20_example,
+};
+use anomapay_erc20_forwarder_integration_test::deploy::permit2::PERMIT2_CANONICAL_ADDRESS;
+use anomapay_erc20_forwarder_integration_test::fixtures::{transfer, unwrap, wrap};
+use anomapay_erc20_forwarder_integration_test::state::forwarder::addresses::erc20_forwarder_v1_address;
+use anyhow::Context;
+#[cfg(feature = "e2e")]
+use common::setup_transfer_generic_call_e2e_env;
+use common::{commitment_root, execute_tx, prove_actions, setup_transfer_generic_call_local_env};
+use it::deploy::dex_router::deploy_dex_router_mock;
+use it::fixtures::generic_call;
+use it::state::addresses::generic_call_forwarder_v1_address;
+use rstest::*;
+
+use anoma_generic_call_witness::GenericCall;
+
+// Calldata interfaces for the calls the generic-call forwarder makes during the
+// swap. Only the function selectors matter for encoding, so these are declared
+// locally rather than pulled from full contract bindings.
+sol! {
+ interface IErc20 {
+ function approve(address spender, uint256 amount) external returns (bool);
+ }
+ interface IPermit2 {
+ function approve(address token, address spender, uint160 amount, uint48 expiration) external;
+ }
+ interface IDexRouter {
+ function swapExactTokensForTokens(
+ uint256 amountIn,
+ uint256 amountOutMin,
+ address[] path,
+ address to,
+ uint256 deadline
+ ) external returns (uint256);
+ }
+}
+
+async fn erc20_balance(
+ token: Address,
+ holder: Address,
+ provider: P,
+) -> anyhow::Result {
+ erc20_example(token, provider)
+ .balanceOf(holder)
+ .call()
+ .await
+ .context("failed to read ERC20 balance")
+}
+
+#[rstest]
+#[case::local(setup_transfer_generic_call_local_env())]
+#[cfg_attr(feature = "e2e", case::e2e_test(setup_transfer_generic_call_e2e_env()))]
+#[tokio::test]
+async fn calls_allow_to_swap_erc20s_on_a_dex(
+ #[future(awt)]
+ #[case]
+ env_with_setup: anyhow::Result,
+) -> anyhow::Result<()> {
+ let mut env = env_with_setup.context("env setup failed")?;
+ let chain_id = chain_id(&env)?;
+ let erc20_forwarder = erc20_forwarder_v1_address(&env)?;
+ let generic_forwarder = generic_call_forwarder_v1_address(&env)?;
+ let provider = default_signer(&env).context("failed to retrieve default signer")?;
+
+ let sender = identities::alice().context("failed to build sender keychain")?;
+
+ let amount_in = 100u128;
+ let amount_out = 50u128; // the mock router pays out a fixed amountOutMin
+ let amount_in_u256 = U256::from(amount_in);
+ let amount_out_u256 = U256::from(amount_out);
+
+ // Deploy token A (minted to the wrapper), the DEX router, and token B (minted
+ // to the router so it can pay out the swap).
+ let token_a = deploy_and_mint_example_erc20(provider.clone(), sender.address(), amount_in_u256)
+ .await
+ .context("failed to deploy token A")?;
+ let dex_router = deploy_dex_router_mock(provider.clone(), PERMIT2_CANONICAL_ADDRESS)
+ .await
+ .context("failed to deploy DEX router")?;
+ let token_b = deploy_and_mint_example_erc20(provider.clone(), dex_router, amount_out_u256)
+ .await
+ .context("failed to deploy token B")?;
+
+ // The wrapper grants Permit2 an allowance so the wrap can pull token A.
+ erc20_example(token_a, provider.clone())
+ .approve(PERMIT2_CANONICAL_ADDRESS, U256::MAX)
+ .send()
+ .await
+ .context("failed to submit token A Permit2 approval")?
+ .get_receipt()
+ .await
+ .context("failed to fetch token A Permit2 approval receipt")?;
+
+ let before_root = commitment_root(&env)?;
+
+ // 1. Wrap token A into a shielded resource.
+ let wrap = wrap::build(
+ chain_id,
+ erc20_forwarder,
+ token_a,
+ amount_in,
+ 11,
+ wrap::Overrides::default(),
+ )
+ .await
+ .context("failed to build token A wrap action")?;
+ let tx = prove_actions(&env, &[wrap.witnesses])
+ .await
+ .context("failed to prove token A wrap action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute token A wrap action")?;
+
+ // 2. Transfer the resource (sender -> receiver) so the receiver can unwrap it.
+ let transfer_path = env
+ .protocol_adapter()
+ .commitment_tree()
+ .path_to(wrap.created_persistent.commitment())
+ .context("failed to generate transfer merkle path")?;
+ let transferred = transfer::build(
+ wrap.created_persistent,
+ erc20_forwarder,
+ token_a,
+ 17,
+ Some(transfer_path),
+ transfer::Overrides::default(),
+ )
+ .context("failed to build transfer action")?;
+ let tx = prove_actions(&env, &[transferred.witnesses])
+ .await
+ .context("failed to prove transfer action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute transfer action")?;
+
+ // 3. Unwrap token A into the generic-call forwarder.
+ let unwrap_path = env
+ .protocol_adapter()
+ .commitment_tree()
+ .path_to(transferred.created_persistent.commitment())
+ .context("failed to generate unwrap merkle path")?;
+ let unwrap = unwrap::build(
+ transferred.created_persistent,
+ erc20_forwarder,
+ token_a,
+ 21,
+ Some(unwrap_path),
+ unwrap::Overrides {
+ ethereum_account_addr: Some(generic_forwarder.to_vec()),
+ ..Default::default()
+ },
+ )
+ .context("failed to build unwrap action")?;
+ let tx = prove_actions(&env, &[unwrap.witnesses])
+ .await
+ .context("failed to prove unwrap action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute unwrap action")?;
+
+ anyhow::ensure!(
+ erc20_balance(token_a, generic_forwarder, provider.clone()).await? == amount_in_u256,
+ "generic-call forwarder must hold token A after the unwrap"
+ );
+ anyhow::ensure!(
+ erc20_balance(token_a, erc20_forwarder, provider.clone()).await? == U256::ZERO,
+ "ERC20 forwarder must hold no token A after the unwrap"
+ );
+
+ // 4. Generic call: from inside the forwarder, approve Permit2 + the router to
+ // pull token A, swap token A -> token B (paid back to the forwarder), and
+ // approve Permit2 to spend token B for the subsequent wrap.
+ let expiration = U48::from(4_294_967_295u64);
+ let calls = vec![
+ GenericCall {
+ to: token_a.to_vec(),
+ value: 0,
+ data: IErc20::approveCall {
+ spender: PERMIT2_CANONICAL_ADDRESS,
+ amount: amount_in_u256,
+ }
+ .abi_encode(),
+ },
+ GenericCall {
+ to: PERMIT2_CANONICAL_ADDRESS.to_vec(),
+ value: 0,
+ data: IPermit2::approveCall {
+ token: token_a,
+ spender: dex_router,
+ amount: U160::from(amount_in),
+ expiration,
+ }
+ .abi_encode(),
+ },
+ GenericCall {
+ to: dex_router.to_vec(),
+ value: 0,
+ data: IDexRouter::swapExactTokensForTokensCall {
+ amountIn: amount_in_u256,
+ amountOutMin: amount_out_u256,
+ path: vec![token_a, token_b],
+ to: generic_forwarder,
+ deadline: U256::from(4_294_967_295u64),
+ }
+ .abi_encode(),
+ },
+ GenericCall {
+ to: token_b.to_vec(),
+ value: 0,
+ data: IErc20::approveCall {
+ spender: PERMIT2_CANONICAL_ADDRESS,
+ amount: amount_out_u256,
+ }
+ .abi_encode(),
+ },
+ ];
+
+ let swap = generic_call::build(
+ 31,
+ generic_forwarder.to_vec(),
+ calls,
+ generic_call::Overrides::default(),
+ )
+ .context("failed to build generic call swap action")?;
+
+ let tx = prove_actions(&env, &[swap.witnesses])
+ .await
+ .context("failed to prove generic call swap action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute generic call swap action")?;
+
+ anyhow::ensure!(
+ erc20_balance(token_a, generic_forwarder, provider.clone()).await? == U256::ZERO,
+ "generic-call forwarder must hold no token A after the swap"
+ );
+ anyhow::ensure!(
+ erc20_balance(token_b, generic_forwarder, provider.clone()).await? == amount_out_u256,
+ "generic-call forwarder must hold token B after the swap"
+ );
+ anyhow::ensure!(
+ erc20_balance(token_a, dex_router, provider.clone()).await? == amount_in_u256,
+ "DEX router must have pulled token A during the swap"
+ );
+
+ // 5. Wrap token B (held by the generic-call forwarder) back into a resource.
+ // The forwarder authorizes the Permit2 pull via ERC-1271, so the permit
+ // signature is an accepted 65-byte placeholder.
+ let mut dummy_permit_sig = vec![0u8; 65];
+ dummy_permit_sig[64] = 27;
+ let wrap_b = wrap::build(
+ chain_id,
+ erc20_forwarder,
+ token_b,
+ amount_out,
+ 41,
+ wrap::Overrides {
+ ethereum_account_addr: Some(generic_forwarder.to_vec()),
+ permit_signature: Some(dummy_permit_sig),
+ ..Default::default()
+ },
+ )
+ .await
+ .context("failed to build token B wrap action")?;
+ let tx = prove_actions(&env, &[wrap_b.witnesses])
+ .await
+ .context("failed to prove token B wrap action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute token B wrap action")?;
+
+ anyhow::ensure!(
+ erc20_balance(token_b, erc20_forwarder, provider.clone()).await? == amount_out_u256,
+ "ERC20 forwarder must hold token B after the wrap-back"
+ );
+ anyhow::ensure!(
+ erc20_balance(token_b, generic_forwarder, provider.clone()).await? == U256::ZERO,
+ "generic-call forwarder must hold no token B after the wrap-back"
+ );
+
+ let after_root = commitment_root(&env)?;
+ anyhow::ensure!(
+ before_root != after_root,
+ "commitment tree root must change"
+ );
+
+ Ok(())
+}
diff --git a/crates/integration-test/tests/unwrap_native_tokens.rs b/crates/integration-test/tests/unwrap_native_tokens.rs
new file mode 100644
index 0000000..373743a
--- /dev/null
+++ b/crates/integration-test/tests/unwrap_native_tokens.rs
@@ -0,0 +1,249 @@
+use alloy::primitives::U256;
+use alloy::providers::Provider;
+use alloy::sol_types::SolCall;
+use anoma_generic_call_forwarder_integration_test as it;
+use anoma_pa_evm_integration_test::state::actors::default_signer;
+
+mod common;
+use anoma_pa_evm_integration_test::keychain::EvmSigner;
+use anoma_pa_evm_integration_test::state::chains::chain_id;
+use anoma_pa_testkit::environment::CommitmentTree;
+use anoma_pa_testkit::environment::Environment;
+use anoma_pa_testkit::environment::ProtocolAdapter;
+use anoma_pa_testkit::fixtures::identities;
+use anomapay_erc20_forwarder_integration_test::deploy::erc20::ierc20_bindings::ierc20;
+use anomapay_erc20_forwarder_integration_test::deploy::erc20::weth_bindings::WETH9;
+use anomapay_erc20_forwarder_integration_test::fixtures::{transfer, unwrap, wrap};
+use anomapay_erc20_forwarder_integration_test::state::erc20::addresses::erc20_address;
+use anomapay_erc20_forwarder_integration_test::state::forwarder::addresses::erc20_forwarder_v1_address;
+use anyhow::Context;
+#[cfg(feature = "e2e")]
+use common::setup_transfer_generic_call_e2e_env;
+use common::{commitment_root, execute_tx, prove_actions, setup_transfer_generic_call_local_env};
+use it::fixtures::generic_call;
+use it::state::addresses::generic_call_forwarder_v1_address;
+use rstest::*;
+
+use anoma_generic_call_witness::GenericCall;
+
+#[rstest]
+#[case::local(setup_transfer_generic_call_local_env())]
+#[cfg_attr(feature = "e2e", case::e2e_test(setup_transfer_generic_call_e2e_env()))]
+#[tokio::test]
+async fn calls_allow_to_unwrap_native_tokens(
+ #[future(awt)]
+ #[case]
+ env_with_setup: anyhow::Result,
+) -> anyhow::Result<()> {
+ let mut env = env_with_setup.context("env setup failed")?;
+ let chain_id = chain_id(&env)?;
+ let erc20_forwarder = erc20_forwarder_v1_address(&env)?;
+ let generic_forwarder = generic_call_forwarder_v1_address(&env)?;
+ let weth = erc20_address(&env, "weth")?;
+ let provider = default_signer(&env).context("failed to retrieve default signer")?;
+
+ let amount = 1u128;
+ let amount_u256 = U256::from(amount);
+ let sender = identities::alice().context("failed to build sender keychain")?;
+ let recipient = identities::bob().context("failed to build recipient keychain")?;
+
+ let before_root = commitment_root(&env)?;
+
+ let sender_weth_before = ierc20(weth, provider.clone())
+ .balanceOf(sender.address())
+ .call()
+ .await
+ .context("failed to read sender WETH balance before wrap")?;
+ let erc20_forwarder_weth_before_wrap = ierc20(weth, provider.clone())
+ .balanceOf(erc20_forwarder)
+ .call()
+ .await
+ .context("failed to read ERC20 forwarder WETH balance before wrap")?;
+ let generic_forwarder_weth_before_unwrap = ierc20(weth, provider.clone())
+ .balanceOf(generic_forwarder)
+ .call()
+ .await
+ .context("failed to read generic call forwarder WETH balance before unwrap")?;
+ let rand_seed = 11;
+
+ let wrap = wrap::build(
+ chain_id,
+ erc20_forwarder,
+ weth,
+ amount,
+ rand_seed,
+ wrap::Overrides::default(),
+ )
+ .await
+ .context("failed to build wrap action")?;
+ let tx = prove_actions(&env, &[wrap.witnesses])
+ .await
+ .context("failed to prove wrap action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute wrap action")?;
+
+ let sender_weth_after_wrap = ierc20(weth, provider.clone())
+ .balanceOf(sender.address())
+ .call()
+ .await
+ .context("failed to read sender WETH balance after wrap")?;
+ anyhow::ensure!(
+ sender_weth_before - sender_weth_after_wrap == amount_u256,
+ "sender WETH must decrease by wrap amount"
+ );
+
+ let erc20_forwarder_weth_after_wrap = ierc20(weth, provider.clone())
+ .balanceOf(erc20_forwarder)
+ .call()
+ .await
+ .context("failed to read ERC20 forwarder WETH balance after wrap")?;
+ anyhow::ensure!(
+ erc20_forwarder_weth_after_wrap - erc20_forwarder_weth_before_wrap == amount_u256,
+ "ERC20 forwarder WETH must equal wrap amount"
+ );
+
+ let created_persistent_merkle_path = env
+ .protocol_adapter()
+ .commitment_tree()
+ .path_to(wrap.created_persistent.commitment())
+ .context("failed to generate transfer merkle path")?;
+
+ let rand_seed = 17;
+
+ let transfer = transfer::build(
+ wrap.created_persistent,
+ erc20_forwarder,
+ weth,
+ rand_seed,
+ Some(created_persistent_merkle_path),
+ transfer::Overrides::default(),
+ )
+ .context("failed to build transfer action")?;
+ let tx = prove_actions(&env, &[transfer.witnesses])
+ .await
+ .context("failed to prove transfer action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute transfer action")?;
+
+ let unwrap_merkle_path = env
+ .protocol_adapter()
+ .commitment_tree()
+ .path_to(transfer.created_persistent.commitment())
+ .context("failed to generate unwrap merkle path")?;
+
+ let rand_seed = 21;
+
+ let unwrap = unwrap::build(
+ transfer.created_persistent,
+ erc20_forwarder,
+ weth,
+ rand_seed,
+ Some(unwrap_merkle_path),
+ unwrap::Overrides {
+ ethereum_account_addr: Some(generic_forwarder.to_vec()),
+ ..unwrap::Overrides::default()
+ },
+ )
+ .context("failed to build unwrap action")?;
+
+ let calls = vec![
+ GenericCall {
+ to: weth.to_vec(),
+ value: 0,
+ data: WETH9::withdrawCall { wad: amount_u256 }.abi_encode(),
+ },
+ GenericCall {
+ to: recipient.address().to_vec(),
+ value: amount,
+ data: Vec::new(),
+ },
+ ];
+
+ let rand_seed = 31;
+
+ let generic_call_action = generic_call::build(
+ rand_seed,
+ generic_forwarder.to_vec(),
+ calls,
+ generic_call::Overrides::default(),
+ )
+ .context("failed to build generic call action")?
+ .witnesses;
+
+ let tx = prove_actions(&env, &[unwrap.witnesses])
+ .await
+ .context("failed to prove unwrap action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute unwrap action")?;
+
+ let generic_forwarder_weth_after_unwrap = ierc20(weth, provider.clone())
+ .balanceOf(generic_forwarder)
+ .call()
+ .await
+ .context("failed to read generic call forwarder WETH balance after unwrap")?;
+ anyhow::ensure!(
+ generic_forwarder_weth_after_unwrap - generic_forwarder_weth_before_unwrap == amount_u256,
+ "generic call forwarder WETH must equal unwrap amount before generic call"
+ );
+
+ let recipient_eth_before = provider
+ .get_balance(recipient.address())
+ .await
+ .context("failed to read recipient ETH balance before")?;
+
+ let tx = prove_actions(&env, &[generic_call_action])
+ .await
+ .context("failed to prove generic call action")?;
+ execute_tx(&mut env, tx)
+ .await
+ .context("failed to execute generic call action")?;
+
+ let erc20_forwarder_weth_after = ierc20(weth, provider.clone())
+ .balanceOf(erc20_forwarder)
+ .call()
+ .await
+ .context("failed to read ERC20 forwarder WETH balance after generic call")?;
+ anyhow::ensure!(
+ erc20_forwarder_weth_after == U256::ZERO,
+ "ERC20 forwarder WETH should be zero after unwrap"
+ );
+
+ let generic_forwarder_weth_after = ierc20(weth, provider.clone())
+ .balanceOf(generic_forwarder)
+ .call()
+ .await
+ .context("failed to read generic call forwarder WETH balance after generic call")?;
+ anyhow::ensure!(
+ generic_forwarder_weth_after == U256::ZERO,
+ "generic call forwarder WETH should be zero after withdraw"
+ );
+
+ let generic_forwarder_eth_after = provider
+ .get_balance(generic_forwarder)
+ .await
+ .context("failed to read generic call forwarder ETH balance after generic call")?;
+ anyhow::ensure!(
+ generic_forwarder_eth_after == U256::ZERO,
+ "generic call forwarder ETH should be zero after forwarding"
+ );
+
+ let recipient_eth_after = provider
+ .get_balance(recipient.address())
+ .await
+ .context("failed to read recipient ETH balance after")?;
+ anyhow::ensure!(
+ recipient_eth_after - recipient_eth_before == amount_u256,
+ "recipient ETH must increase by transfer amount"
+ );
+
+ let after_root = commitment_root(&env)?;
+ anyhow::ensure!(
+ before_root != after_root,
+ "commitment tree root must change"
+ );
+
+ Ok(())
+}
diff --git a/justfile b/justfile
index 8b4c9cc..635f542 100644
--- a/justfile
+++ b/justfile
@@ -53,7 +53,7 @@ contracts-gen-bindings:
cd contracts && forge clean && forge bind \
--skip test --skip script \
--select '^(GenericCallForwarder)$' \
- --bindings-path ../bindings/src/generated/ \
+ --bindings-path ../crates/bindings/src/generated/ \
--module \
--overwrite
@@ -103,28 +103,28 @@ contracts-publish version *args:
# Clean bindings
bindings-clean:
- cd bindings && cargo clean
+ cd crates/bindings && cargo clean
# Build bindings
bindings-build *args:
- cd bindings && cargo build {{ args }}
+ cd crates/bindings && cargo build {{ args }}
# Test bindings
bindings-test *args:
- cd bindings && cargo test {{ args }}
+ cd crates/bindings && cargo test {{ args }}
# Check bindings are up-to-date
bindings-check: contracts-gen-bindings
- git diff --exit-code bindings/src/generated/
+ git diff --exit-code crates/bindings/src/generated/
# Publish bindings
bindings-publish *args:
- cd bindings && cargo publish {{ args }}
+ cd crates/bindings && cargo publish {{ args }}
# Lint bindings (clippy)
bindings-lint:
- cd bindings && cargo clippy --no-deps -- -Dwarnings
- cd bindings && cargo clippy --no-deps --tests -- -Dwarnings
+ cd crates/bindings && cargo clippy --no-deps -- -Dwarnings
+ cd crates/bindings && cargo clippy --no-deps --tests -- -Dwarnings
# Format bindings
bindings-fmt:
@@ -134,42 +134,68 @@ bindings-fmt:
bindings-fmt-check:
cargo fmt -- --check
+# --- Crates (workspace-wide Rust) ---
+
+# Clean all crates
+crates-clean:
+ cargo clean
+
+# Build all crates
+crates-build *args:
+ cargo build {{ args }}
+
+# Test all crates
+crates-test *args:
+ cargo test {{ args }}
+
+# Lint all crates (clippy)
+crates-lint:
+ cargo clippy --all-targets --no-deps -- -Dwarnings
+
+# Format all crates
+crates-fmt *args:
+ cargo fmt --all {{ args }}
+
+# Check all crates formatting
+crates-fmt-check:
+ cargo fmt --all -- --check
+
# --- All ---
-# Lint all (contracts + bindings)
+# Lint all (contracts + crates)
all-lint:
@echo "==> Linting contracts..."
@just contracts-lint
- @echo "==> Linting bindings..."
- @just bindings-lint
+ @echo "==> Linting crates..."
+ @just crates-lint
-# Format all (contracts + bindings)
+# Format all (contracts + crates)
all-fmt:
@echo "==> Formatting contracts..."
@just contracts-fmt
- @echo "==> Formatting bindings..."
- @just bindings-fmt
+ @echo "==> Formatting crates..."
+ @just crates-fmt
-# Check formatting for all (contracts + bindings)
+# Check formatting for all (contracts + crates)
all-fmt-check:
@echo "==> Checking contract formatting..."
@just contracts-fmt-check
- @echo "==> Checking bindings formatting..."
- @just bindings-fmt-check
+ @echo "==> Checking crates formatting..."
+ @just crates-fmt-check
-# Build all (contracts + bindings)
+# Build all (contracts + crates)
all-build:
@echo "==> Building contracts..."
@just contracts-build
- @echo "==> Building bindings..."
- @just bindings-build
+ @echo "==> Building crates..."
+ @just crates-build
-# Test all (contracts + bindings)
+# Test all (contracts + crates)
all-test:
@echo "==> Testing contracts..."
@just contracts-test
- @echo "==> Testing bindings..."
- @just bindings-test
+ @echo "==> Testing crates..."
+ @just crates-test
# Prerequisites check (mirrors CI)
all-check: