Source – Alkane 2:79108 — SUBFROST Explorer

src/tests/amm_setup.rs8,964 B

//! # AMM Setup Helper
//!
//! This module provides utilities to deploy and initialize the OYL AMM factory
//! following the exact pattern from reference/oyl-protocol.
//!
//! The deployment sequence is:
//! 1. Deploy pool template to [3, AMM_FACTORY_ID] (factory space)
//! 2. Deploy auth token factory to [3, AUTH_TOKEN_FACTORY_ID]
//! 3. Deploy factory logic implementation to [3, AMM_FACTORY_LOGIC_IMPL_TX]
//! 4. Deploy beacon proxy and upgradeable beacon for pool pattern
//! 5. Deploy upgradeable proxy for factory
//! 6. Initialize the factory through the proxy
use crate::tests::helpers::{
init_with_multiple_cellpacks_with_tx, index_block,
create_multiple_cellpack_with_witness_and_in,
};
use crate::tests::vendor::{get_factory_wasm_bytes, get_pool_wasm_bytes};
use crate::test_log;
use alkanes::precompiled::{
alkanes_std_auth_token_build, alkanes_std_beacon_proxy_build,
alkanes_std_upgradeable_beacon_build, alkanes_std_upgradeable_build,
};
use alkanes_support::cellpack::Cellpack;
use alkanes_support::id::AlkaneId;
use anyhow::Result;
use bitcoin::{Block, OutPoint, Witness};
use protorune::test_helpers::create_block_with_coinbase_tx;
// Constants matching mainnet deployment
pub const AMM_FACTORY_ID: u128 = 0xffef; // 65519 - pool template stored here
pub const AUTH_TOKEN_FACTORY_ID: u128 = 0xffed; // 65517
pub const AMM_FACTORY_LOGIC_IMPL_TX: u128 = 2;
pub const POOL_BEACON_PROXY_TX: u128 = 0xbeac1;
pub const POOL_UPGRADEABLE_BEACON_TX: u128 = 0xbeac0;
pub const AMM_FACTORY_PROXY_TX: u128 = 1;
#[derive(Debug, Clone)]
pub struct AmmDeployment {
pub factory_proxy_id: AlkaneId,
pub factory_logic_id: AlkaneId,
pub pool_template_id: AlkaneId,
pub pool_beacon_proxy_id: AlkaneId,
pub pool_upgradeable_beacon_id: AlkaneId,
pub auth_token_factory_id: AlkaneId,
pub factory_auth_token_id: AlkaneId,
pub current_height: u32,
}
/// Deploy all AMM infrastructure contracts
pub fn deploy_amm_infrastructure(start_height: u32) -> Result<(AmmDeployment, OutPoint)> {
test_log!("[AMM] Deploying AMM infrastructure contracts starting at height {}", start_height);
let mut height = start_height;
// 1. Deploy pool template to factory space (for cloning)
test_log!("[AMM] Deploying pool template to [3, {}]", AMM_FACTORY_ID);
let pool_block = init_with_multiple_cellpacks_with_tx(
vec![get_pool_wasm_bytes().to_vec()],
vec![Cellpack {
target: AlkaneId { block: 3, tx: AMM_FACTORY_ID },
inputs: vec![50], // Deployment marker
}],
);
index_block(&pool_block, height)?;
height += 1;
// 2. Deploy auth token factory
test_log!("[AMM] Deploying auth token factory to [3, {}]", AUTH_TOKEN_FACTORY_ID);
let auth_block = init_with_multiple_cellpacks_with_tx(
vec![alkanes_std_auth_token_build::get_bytes().to_vec()],
vec![Cellpack {
target: AlkaneId { block: 3, tx: AUTH_TOKEN_FACTORY_ID },
inputs: vec![100],
}],
);
index_block(&auth_block, height)?;
height += 1;
// 3. Deploy AMM factory logic implementation
test_log!("[AMM] Deploying factory logic to [3, {}]", AMM_FACTORY_LOGIC_IMPL_TX);
let factory_block = init_with_multiple_cellpacks_with_tx(
vec![get_factory_wasm_bytes().to_vec()],
vec![Cellpack {
target: AlkaneId { block: 3, tx: AMM_FACTORY_LOGIC_IMPL_TX },
inputs: vec![50],
}],
);
index_block(&factory_block, height)?;
height += 1;
// 4. Deploy beacon proxy for pools
test_log!("[AMM] Deploying beacon proxy to [3, {}]", POOL_BEACON_PROXY_TX);
let beacon_proxy_block = init_with_multiple_cellpacks_with_tx(
vec![alkanes_std_beacon_proxy_build::get_bytes().to_vec()],
vec![Cellpack {
target: AlkaneId { block: 3, tx: POOL_BEACON_PROXY_TX },
inputs: vec![0x8fff],
}],
);
index_block(&beacon_proxy_block, height)?;
height += 1;
// 5. Deploy upgradeable beacon (points to pool template)
test_log!("[AMM] Deploying upgradeable beacon to [3, {}]", POOL_UPGRADEABLE_BEACON_TX);
let upgradeable_beacon_block = init_with_multiple_cellpacks_with_tx(
vec![alkanes_std_upgradeable_beacon_build::get_bytes().to_vec()],
vec![Cellpack {
target: AlkaneId { block: 3, tx: POOL_UPGRADEABLE_BEACON_TX },
inputs: vec![
0x7fff, // Upgradeable beacon marker
4, // pool_template.block
AMM_FACTORY_ID, // pool_template.tx
1, // version
],
}],
);
index_block(&upgradeable_beacon_block, height)?;
let last_outpoint = OutPoint {
txid: upgradeable_beacon_block.txdata[1].compute_txid(),
vout: 0,
};
height += 1;
test_log!("[AMM] Infrastructure contracts deployed");
let deployment = AmmDeployment {
factory_proxy_id: AlkaneId { block: 0, tx: 0 }, // Will be set after proxy deployment
factory_logic_id: AlkaneId { block: 4, tx: AMM_FACTORY_LOGIC_IMPL_TX },
pool_template_id: AlkaneId { block: 4, tx: AMM_FACTORY_ID },
pool_beacon_proxy_id: AlkaneId { block: 4, tx: POOL_BEACON_PROXY_TX },
pool_upgradeable_beacon_id: AlkaneId { block: 4, tx: POOL_UPGRADEABLE_BEACON_TX },
auth_token_factory_id: AlkaneId { block: 4, tx: AUTH_TOKEN_FACTORY_ID },
factory_auth_token_id: AlkaneId { block: 0, tx: 0 }, // Will be set after proxy deployment
current_height: height,
};
Ok((deployment, last_outpoint))
}
/// Deploy and initialize the factory proxy
pub fn deploy_factory_proxy(
block_height: u32,
input_outpoint: OutPoint,
deployment: &AmmDeployment,
) -> Result<(Block, AlkaneId, AlkaneId)> {
use alkanes::vm::utils::sequence_pointer;
use metashrew_core::index_pointer::AtomicPointer;
use metashrew_support::index_pointer::KeyValuePointer;
use alkanes_support::envelope::RawEnvelope;
test_log!("[AMM] Deploying factory proxy and initializing");
// Get next sequence number for auth token
let next_sequence_pointer = sequence_pointer(&mut AtomicPointer::default());
let auth_sequence = next_sequence_pointer.get_value::<u128>();
// Deploy upgradeable proxy for factory
let proxy_wasm = alkanes_std_upgradeable_build::get_bytes();
let witness = RawEnvelope::from(proxy_wasm.to_vec()).to_witness(true);
let proxy_cellpack = Cellpack {
target: AlkaneId { block: 3, tx: AMM_FACTORY_PROXY_TX },
inputs: vec![
0x7fff, // Upgradeable proxy marker
deployment.factory_logic_id.block,
deployment.factory_logic_id.tx,
1, // version
],
};
let proxy_tx = create_multiple_cellpack_with_witness_and_in(
witness,
vec![proxy_cellpack],
input_outpoint,
false,
);
let mut proxy_block = create_block_with_coinbase_tx(block_height);
proxy_block.txdata.push(proxy_tx);
index_block(&proxy_block, block_height)?;
let proxy_outpoint = OutPoint {
txid: proxy_block.txdata[1].compute_txid(),
vout: 0,
};
// Initialize factory in next block
let init_cellpack = Cellpack {
target: AlkaneId { block: 4, tx: AMM_FACTORY_PROXY_TX },
inputs: vec![
0, // InitFactory opcode
POOL_BEACON_PROXY_TX as u128, // pool_factory_id for cloning
deployment.pool_upgradeable_beacon_id.block,
deployment.pool_upgradeable_beacon_id.tx,
],
};
let init_tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![init_cellpack],
proxy_outpoint,
false,
);
let mut init_block = create_block_with_coinbase_tx(block_height + 1);
init_block.txdata.push(init_tx);
index_block(&init_block, block_height + 1)?;
let factory_proxy_id = AlkaneId { block: 4, tx: AMM_FACTORY_PROXY_TX };
let factory_auth_token_id = AlkaneId { block: 2, tx: auth_sequence };
test_log!("[AMM] Factory proxy deployed: {:?}", factory_proxy_id);
test_log!("[AMM] Factory auth token: {:?}", factory_auth_token_id);
Ok((init_block, factory_proxy_id, factory_auth_token_id))
}
/// Complete AMM setup: deploy infrastructure and initialize factory
pub fn setup_amm(start_height: u32) -> Result<AmmDeployment> {
let (mut deployment, last_outpoint) = deploy_amm_infrastructure(start_height)?;
let (_, factory_proxy_id, factory_auth_token_id) =
deploy_factory_proxy(deployment.current_height, last_outpoint, &deployment)?;
deployment.factory_proxy_id = factory_proxy_id;
deployment.factory_auth_token_id = factory_auth_token_id;
deployment.current_height += 2; // Two more blocks for proxy deployment + init
test_log!("[AMM] AMM setup complete at height {}", deployment.current_height);
Ok(deployment)
}

Verified Source