margin-account-oracle 0.1.0

A cargo-generate template for Rust + Sway integration testing.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use fuels::{
    accounts::{
        signers::private_key::PrivateKeySigner,
        wallet::Unlocked,
    },
    prelude::*,
    types::ContractId,
};

// Load abi from json
abigen!(
    Contract(
        name = "MarginAccountOracle",
        abi =
            "contracts/margin-account-oracle/out/release/margin-account-oracle-abi.json"
    ),
    Contract(
        name = "MarginAccount",
        abi = "contracts/margin-account/out/release/margin-account-abi.json"
    ),
    Contract(
        name = "LargeContract",
        abi =
            "contracts/test_artifacts/large_contract/out/release/large-contract-abi.json"
    )
);

pub async fn deploy_blob(wallet: &Wallet<Unlocked<PrivateKeySigner>>) -> ContractId {
    let max_words_per_blob = 10_000;
    let blobs = Contract::load_from(
        "../test_artifacts/large_contract/out/release/large-contract.bin",
        LoadConfiguration::default(),
    )
    .unwrap()
    .convert_to_loader(max_words_per_blob)
    .unwrap()
    .blobs()
    .to_vec();

    let blob = blobs[0].clone();
    let mut builder = BlobTransactionBuilder::default().with_blob(blob.clone());

    wallet.adjust_for_fee(&mut builder, 0).await.unwrap();
    wallet.add_witnesses(&mut builder).unwrap();

    let tx = builder
        .build(&wallet.try_provider().unwrap())
        .await
        .unwrap();
    wallet
        .try_provider()
        .unwrap()
        .send_transaction_and_await_commit(tx)
        .await
        .unwrap()
        .check(None)
        .unwrap();

    ContractId::from(blob.id())
}

pub async fn setup_wallets() -> (
    Wallet<Unlocked<PrivateKeySigner>>,
    Wallet<Unlocked<PrivateKeySigner>>,
    Wallet<Unlocked<PrivateKeySigner>>,
) {
    // Launch a local network and deploy the contract
    let mut wallets = launch_custom_provider_and_get_wallets(
        WalletsConfig::new(
            Some(3),
            Some(1),             // Single coin (UTXO)
            Some(1_000_000_000), // Amount per coin
        ),
        None,
        None,
    )
    .await
    .unwrap();
    let wallet_1 = wallets.pop().unwrap();
    let wallet_2 = wallets.pop().unwrap();
    let wallet_3 = wallets.pop().unwrap();

    (wallet_1, wallet_2, wallet_3)
}

pub async fn setup_oracle(
    wallet: &Wallet<Unlocked<PrivateKeySigner>>,
) -> (
    MarginAccountOracle<Wallet<Unlocked<PrivateKeySigner>>>,
    ContractId,
) {
    let id = Contract::load_from(
        "./out/release/margin-account-oracle.bin",
        LoadConfiguration::default(),
    )
    .unwrap()
    .deploy(wallet, TxPolicies::default())
    .await
    .unwrap()
    .contract_id;

    let instance = MarginAccountOracle::new(id, wallet.clone());

    (instance, id)
}

pub async fn setup_margin_account(
    wallet: &Wallet<Unlocked<PrivateKeySigner>>,
) -> (
    MarginAccount<Wallet<Unlocked<PrivateKeySigner>>>,
    ContractId,
) {
    let id = Contract::load_from(
        "../margin-account/out/release/margin-account.bin",
        LoadConfiguration::default(),
    )
    .unwrap()
    .deploy(wallet, TxPolicies::default())
    .await
    .unwrap()
    .contract_id;

    let instance = MarginAccount::new(id, wallet.clone());

    (instance, id)
}