Grcov report - integration_realistic_tests_exact

1

use crate::{

2

    helpers::Scaled,

3

    msg::{ExecuteMsg, QueryMsg},

4

    testing::test_utils::{

5

        are_fpdecimals_approximately_equal, assert_fee_is_as_expected, create_ninja_inj_both_side_orders,

6

        create_realistic_atom_usdt_sell_orders_from_spreadsheet, create_realistic_eth_usdt_buy_orders_from_spreadsheet,

7

        create_realistic_eth_usdt_sell_orders_from_spreadsheet, create_realistic_inj_usdt_buy_orders_from_spreadsheet,

8

        create_realistic_inj_usdt_sell_orders_from_spreadsheet, create_realistic_limit_order, create_realistic_usdt_usdc_both_side_orders,

9

        human_to_dec, init_rich_account, init_self_relaying_contract_and_get_address, initial_coin, launch_realistic_atom_usdt_spot_market,

10

        launch_realistic_inj_usdt_spot_market, launch_realistic_ninja_inj_spot_market, launch_realistic_usdt_usdc_spot_market,

11

        launch_realistic_weth_usdt_spot_market, must_init_account_with_funds_and_setting_denoms, query_all_bank_balances, query_bank_balance,

12

        set_route_and_assert_success, str_coin, Decimals, OrderSide, ATOM, ETH, INJ, INJ_2, NINJA, USDC, USDT,

13

},

14

    types::{FPCoin, SwapEstimationResult},

15

};

16

17

use injective_math::FPDecimal;

18

use injective_test_tube::{Account, Bank, Exchange, InjectiveTestApp, Module, Wasm};

19

use std::ops::Neg;

20

21

/*

22

   This test suite focuses on using using realistic values both for spot markets and for orders and

23

   focuses on swaps requesting exact amount. This works as expected apart, when we are converting very

24

   low quantities from a source asset that is orders of magnitude more expensive than the target

25

   asset (as we round up to min quantity tick size).

26

27

   ATOM/USDT market parameters was taken from mainnet. ETH/USDT market parameters mirror WETH/USDT

28

   spot market on mainnet. INJ_2/USDT mirrors mainnet's INJ/USDT market (we used a different denom

29

   to avoid mixing balance changes related to gas payments).

30

31

   All values used in these tests come from the 2nd, 3rd and 4th tab of this spreadsheet:

32

   https://docs.google.com/spreadsheets/d/1-0epjX580nDO_P2mm1tSjhvjJVppsvrO1BC4_wsBeyA/edit?usp=sharing

33

34

   In all tests contract is configured to self-relay trades and thus receive a 60% fee discount.

35

*/

36

37

struct Percent<'a>(&'a str);

38

39

#[test]

40

2

fn it_swaps_eth_to_get_minimum_exact_amount_of_atom_by_mildly_rounding_up() {

41

2

    exact_two_hop_eth_atom_swap_test_template(human_to_dec("0.01", Decimals::Six), Percent("2200"))

42

2

43

44

#[test]

45

2

fn it_swaps_eth_to_get_very_low_exact_amount_of_atom_by_heavily_rounding_up() {

46

2

    exact_two_hop_eth_atom_swap_test_template(human_to_dec("0.11", Decimals::Six), Percent("110"))

47

2

48

49

#[test]

50

2

fn it_swaps_eth_to_get_low_exact_amount_of_atom_by_rounding_up() {

51

2

    exact_two_hop_eth_atom_swap_test_template(human_to_dec("4.12", Decimals::Six), Percent("10"))

52

2

53

54

#[test]

55

2

fn it_correctly_swaps_eth_to_get_normal_exact_amount_of_atom() {

56

2

    exact_two_hop_eth_atom_swap_test_template(human_to_dec("12.05", Decimals::Six), Percent("1"))

57

2

58

59

#[test]

60

2

fn it_correctly_swaps_eth_to_get_high_exact_amount_of_atom() {

61

2

    exact_two_hop_eth_atom_swap_test_template(human_to_dec("612", Decimals::Six), Percent("1"))

62

2

63

64

#[test]

65

2

fn it_correctly_swaps_eth_to_get_very_high_exact_amount_of_atom() {

66

2

    let app = InjectiveTestApp::new();

67

2

    let wasm = Wasm::new(&app);

68

2

    let exchange = Exchange::new(&app);

69

2

    let bank = Bank::new(&app);

70

2

71

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

72

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

73

2

74

2

    let owner = must_init_account_with_funds_and_setting_denoms(

75

2

        &app,

76

2

        &validator,

77

2

&[

78

2

            initial_coin("1", ETH, Decimals::Eighteen),

79

2

            initial_coin("1", ATOM, Decimals::Six),

80

2

            initial_coin("1_000", USDT, Decimals::Six),

81

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

82

2

],

83

2

);

84

2

85

2

    let spot_market_1_id = launch_realistic_weth_usdt_spot_market(&exchange, &owner);

86

2

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

87

2

88

2

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

89

2

    set_route_and_assert_success(

90

2

        &wasm,

91

2

        &owner,

92

2

        &contr_addr,

93

2

        ETH,

94

2

        ATOM,

95

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

96

2

);

97

2

98

2

    let trader1 = init_rich_account(&app);

99

2

    let trader2 = init_rich_account(&app);

100

2

    let trader3 = init_rich_account(&app);

101

2

102

2

    create_realistic_eth_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

103

2

    create_realistic_limit_order(

104

2

        &app,

105

2

        &trader1,

106

2

        &spot_market_1_id,

107

2

        OrderSide::Buy,

108

2

        "2137.2",

109

2

        "2.78",

110

2

        Decimals::Eighteen,

111

2

        Decimals::Six,

112

2

    ); //order not present in the spreadsheet

113

2

114

2

    create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

115

2

    create_realistic_limit_order(

116

2

        &app,

117

2

        &trader1,

118

2

        &spot_market_2_id,

119

2

        OrderSide::Sell,

120

2

        "9.11",

121

2

        "321.11",

122

2

        Decimals::Six,

123

2

        Decimals::Six,

124

2

    ); //order not present in the spreadsheet

125

2

126

2

    app.increase_time(1);

127

2

128

2

    let eth_to_swap = "4.4";

129

2

130

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

131

2

        &app,

132

2

        &validator,

133

2

&[

134

2

            initial_coin(eth_to_swap, ETH, Decimals::Eighteen),

135

2

            initial_coin("1", INJ, Decimals::Eighteen),

136

2

],

137

2

);

138

2

139

2

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

140

2

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

141

142

2

    let exact_quantity_to_receive = human_to_dec("1014.19", Decimals::Six);

143

2

144

2

    let query_result: SwapEstimationResult = wasm

145

2

        .query(

146

2

            &contr_addr,

147

2

            &QueryMsg::GetInputQuantity {

148

2

                source_denom: ETH.to_string(),

149

2

                target_denom: ATOM.to_string(),

150

2

                to_quantity: exact_quantity_to_receive,

151

2

},

152

2

153

2

        .unwrap();

154

2

155

2

    wasm.execute(

156

2

        &contr_addr,

157

2

        &ExecuteMsg::SwapExactOutput {

158

2

            target_denom: ATOM.to_string(),

159

2

            target_output_quantity: exact_quantity_to_receive,

160

2

},

161

2

        &[str_coin(eth_to_swap, ETH, Decimals::Eighteen)],

162

2

        &swapper,

163

2

164

2

    .unwrap();

165

2

166

2

    let expected_difference = human_to_dec(eth_to_swap, Decimals::Eighteen) - query_result.result_quantity;

167

2

    let swapper_eth_balance_after = query_bank_balance(&bank, ETH, swapper.address().as_str());

168

2

    let swapper_atom_balance_after = query_bank_balance(&bank, ATOM, swapper.address().as_str());

169

2

170

2

    assert_eq!(swapper_eth_balance_after, expected_difference, "wrong amount of ETH was exchanged");

171

172

2

    assert!(

173

2

        swapper_atom_balance_after >= exact_quantity_to_receive,

174

        "swapper got less than exact amount required -> expected: {} ATOM, actual: {} ATOM",

175

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

176

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg())

177

);

178

179

2

    let one_percent_diff = exact_quantity_to_receive * FPDecimal::must_from_str("0.01");

180

2

181

2

    assert!(

182

2

        are_fpdecimals_approximately_equal(swapper_atom_balance_after, exact_quantity_to_receive, one_percent_diff,),

183

        "swapper did not receive expected exact amount +/- 1% -> expected: {} ATOM, actual: {} ATOM, max diff: {} ATOM",

184

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

185

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg()),

186

        one_percent_diff.scaled(Decimals::Six.get_decimals().neg())

187

);

188

189

2

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

190

2

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

191

192

2

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

193

2

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

194

2

195

2

    assert!(

196

2

        contract_usdt_balance_after >= contract_usdt_balance_before,

197

        "Contract lost some money after swap. Actual balance: {contract_usdt_balance_after}, previous balance: {contract_usdt_balance_before}",

198

);

199

200

    // contract is allowed to earn extra 0.73 USDT from the swap of ~$8450 worth of ETH

201

2

    let max_diff = human_to_dec("0.8", Decimals::Six);

202

2

203

2

    assert!(

204

2

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

205

        "Contract balance changed too much. Actual balance: {}, previous balance: {}. Max diff: {}",

206

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

207

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

208

        max_diff.scaled(Decimals::Six.get_decimals().neg())

209

);

210

2

211

212

#[test]

213

2

fn it_swaps_inj_to_get_minimum_exact_amount_of_atom_by_mildly_rounding_up() {

214

2

    exact_two_hop_inj_atom_swap_test_template(human_to_dec("0.01", Decimals::Six), Percent("0"))

215

2

216

217

#[test]

218

2

fn it_swaps_inj_to_get_very_low_exact_amount_of_atom() {

219

2

    exact_two_hop_inj_atom_swap_test_template(human_to_dec("0.11", Decimals::Six), Percent("0"))

220

2

221

222

#[test]

223

2

fn it_swaps_inj_to_get_low_exact_amount_of_atom() {

224

2

    exact_two_hop_inj_atom_swap_test_template(human_to_dec("4.12", Decimals::Six), Percent("0"))

225

2

226

227

#[test]

228

2

fn it_correctly_swaps_inj_to_get_normal_exact_amount_of_atom() {

229

2

    exact_two_hop_inj_atom_swap_test_template(human_to_dec("12.05", Decimals::Six), Percent("0"))

230

2

231

232

#[test]

233

2

fn it_correctly_swaps_inj_to_get_high_exact_amount_of_atom() {

234

2

    exact_two_hop_inj_atom_swap_test_template(human_to_dec("612", Decimals::Six), Percent("0.01"))

235

2

236

237

#[test]

238

2

fn it_correctly_swaps_inj_to_get_very_high_exact_amount_of_atom() {

239

2

    let app = InjectiveTestApp::new();

240

2

    let wasm = Wasm::new(&app);

241

2

    let exchange = Exchange::new(&app);

242

2

    let bank = Bank::new(&app);

243

2

244

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

245

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

246

2

247

2

    let owner = must_init_account_with_funds_and_setting_denoms(

248

2

        &app,

249

2

        &validator,

250

2

&[

251

2

            initial_coin("1", ETH, Decimals::Eighteen),

252

2

            initial_coin("1", ATOM, Decimals::Six),

253

2

            initial_coin("1_000", USDT, Decimals::Six),

254

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

255

2

            initial_coin("10_000", INJ_2, Decimals::Eighteen),

256

2

],

257

2

);

258

2

259

2

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

260

2

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

261

2

262

2

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

263

2

    set_route_and_assert_success(

264

2

        &wasm,

265

2

        &owner,

266

2

        &contr_addr,

267

2

        INJ_2,

268

2

        ATOM,

269

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

270

2

);

271

2

272

2

    let trader1 = init_rich_account(&app);

273

2

    let trader2 = init_rich_account(&app);

274

2

    let trader3 = init_rich_account(&app);

275

2

276

2

    create_realistic_inj_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

277

2

    create_realistic_limit_order(

278

2

        &app,

279

2

        &trader1,

280

2

        &spot_market_1_id,

281

2

        OrderSide::Buy,

282

2

        "8.99",

283

2

        "280.2",

284

2

        Decimals::Eighteen,

285

2

        Decimals::Six,

286

2

    ); //order not present in the spreadsheet

287

2

288

2

    create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

289

2

    create_realistic_limit_order(

290

2

        &app,

291

2

        &trader1,

292

2

        &spot_market_2_id,

293

2

        OrderSide::Sell,

294

2

        "9.11",

295

2

        "321.11",

296

2

        Decimals::Six,

297

2

        Decimals::Six,

298

2

    ); //order not present in the spreadsheet

299

2

300

2

    app.increase_time(1);

301

2

302

2

    let inj_to_swap = "1100.1";

303

2

304

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

305

2

        &app,

306

2

        &validator,

307

2

&[

308

2

            initial_coin(inj_to_swap, INJ_2, Decimals::Eighteen),

309

2

            initial_coin("1", INJ, Decimals::Eighteen),

310

2

],

311

2

);

312

2

313

2

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

314

2

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

315

316

2

    let exact_quantity_to_receive = human_to_dec("1010.12", Decimals::Six);

317

2

    let max_diff_percentage = Percent("0.01");

318

2

319

2

    let query_result: SwapEstimationResult = wasm

320

2

        .query(

321

2

            &contr_addr,

322

2

            &QueryMsg::GetInputQuantity {

323

2

                source_denom: INJ_2.to_string(),

324

2

                target_denom: ATOM.to_string(),

325

2

                to_quantity: exact_quantity_to_receive,

326

2

},

327

2

328

2

        .unwrap();

329

2

330

2

    wasm.execute(

331

2

        &contr_addr,

332

2

        &ExecuteMsg::SwapExactOutput {

333

2

            target_denom: ATOM.to_string(),

334

2

            target_output_quantity: exact_quantity_to_receive,

335

2

},

336

2

        &[str_coin(inj_to_swap, INJ_2, Decimals::Eighteen)],

337

2

        &swapper,

338

2

339

2

    .unwrap();

340

2

341

2

    let expected_difference = human_to_dec(inj_to_swap, Decimals::Eighteen) - query_result.result_quantity;

342

2

    let swapper_inj_balance_after = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

343

2

    let swapper_atom_balance_after = query_bank_balance(&bank, ATOM, swapper.address().as_str());

344

2

345

2

    assert_eq!(swapper_inj_balance_after, expected_difference, "wrong amount of INJ was exchanged");

346

347

2

    assert!(

348

2

        swapper_atom_balance_after >= exact_quantity_to_receive,

349

        "swapper got less than exact amount required -> expected: {} ATOM, actual: {} ATOM",

350

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

351

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg())

352

);

353

354

2

    let one_percent_diff = exact_quantity_to_receive * (FPDecimal::must_from_str(max_diff_percentage.0) / FPDecimal::from(100u128));

355

2

356

2

    assert!(

357

2

        are_fpdecimals_approximately_equal(swapper_atom_balance_after, exact_quantity_to_receive, one_percent_diff,),

358

        "swapper did not receive expected exact ATOM amount +/- {}% -> expected: {} ATOM, actual: {} ATOM, max diff: {} ATOM",

359

        max_diff_percentage.0,

360

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

361

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg()),

362

        one_percent_diff.scaled(Decimals::Six.get_decimals().neg())

363

);

364

365

2

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

366

2

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

367

368

2

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

369

2

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

370

2

371

2

    assert!(

372

2

        contract_usdt_balance_after >= contract_usdt_balance_before,

373

        "Contract lost some money after swap. Actual balance: {contract_usdt_balance_after}, previous balance: {contract_usdt_balance_before}",

374

);

375

376

    // contract is allowed to earn extra 0.7 USDT from the swap of ~$8150 worth of INJ

377

2

    let max_diff = human_to_dec("0.7", Decimals::Six);

378

2

379

2

    assert!(

380

2

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

381

        "Contract balance changed too much. Actual balance: {} USDT, previous balance: {} USDT. Max diff: {} USDT",

382

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

383

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

384

        max_diff.scaled(Decimals::Six.get_decimals().neg())

385

);

386

2

387

388

#[test]

389

2

fn it_swaps_inj_to_get_minimum_exact_amount_of_eth() {

390

2

    exact_two_hop_inj_eth_swap_test_template(human_to_dec("0.001", Decimals::Eighteen), Percent("0"))

391

2

392

393

#[test]

394

2

fn it_swaps_inj_to_get_low_exact_amount_of_eth() {

395

2

    exact_two_hop_inj_eth_swap_test_template(human_to_dec("0.012", Decimals::Eighteen), Percent("0"))

396

2

397

398

#[test]

399

2

fn it_swaps_inj_to_get_normal_exact_amount_of_eth() {

400

2

    exact_two_hop_inj_eth_swap_test_template(human_to_dec("0.1", Decimals::Eighteen), Percent("0"))

401

2

402

403

#[test]

404

2

fn it_swaps_inj_to_get_high_exact_amount_of_eth() {

405

2

    exact_two_hop_inj_eth_swap_test_template(human_to_dec("3.1", Decimals::Eighteen), Percent("0"))

406

2

407

408

#[test]

409

2

fn it_swaps_inj_to_get_very_high_exact_amount_of_eth() {

410

2

    let app = InjectiveTestApp::new();

411

2

    let wasm = Wasm::new(&app);

412

2

    let exchange = Exchange::new(&app);

413

2

    let bank = Bank::new(&app);

414

2

415

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

416

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

417

2

418

2

    let owner = must_init_account_with_funds_and_setting_denoms(

419

2

        &app,

420

2

        &validator,

421

2

&[

422

2

            initial_coin("1", ETH, Decimals::Eighteen),

423

2

            initial_coin("1_000", USDT, Decimals::Six),

424

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

425

2

            initial_coin("10_000", INJ_2, Decimals::Eighteen),

426

2

],

427

2

);

428

2

429

2

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

430

2

    let spot_market_2_id = launch_realistic_weth_usdt_spot_market(&exchange, &owner);

431

2

432

2

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

433

2

    set_route_and_assert_success(

434

2

        &wasm,

435

2

        &owner,

436

2

        &contr_addr,

437

2

        INJ_2,

438

2

        ETH,

439

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

440

2

);

441

2

442

2

    let trader1 = init_rich_account(&app);

443

2

    let trader2 = init_rich_account(&app);

444

2

    let trader3 = init_rich_account(&app);

445

2

446

2

    create_realistic_inj_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

447

2

    create_realistic_limit_order(

448

2

        &app,

449

2

        &trader1,

450

2

        &spot_market_1_id,

451

2

        OrderSide::Buy,

452

2

        "8.99",

453

2

        "1882.001",

454

2

        Decimals::Eighteen,

455

2

        Decimals::Six,

456

2

    ); //order not present in the spreadsheet

457

2

    create_realistic_eth_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

458

2

    create_realistic_limit_order(

459

2

        &app,

460

2

        &trader3,

461

2

        &spot_market_2_id,

462

2

        OrderSide::Sell,

463

2

        "2123.1",

464

2

        "18.11",

465

2

        Decimals::Eighteen,

466

2

        Decimals::Six,

467

2

    ); //order not present in the spreadsheet

468

2

469

2

    app.increase_time(1);

470

2

471

2

    let inj_to_swap = "2855.259";

472

2

    let exact_quantity_to_receive = human_to_dec("11.2", Decimals::Eighteen);

473

2

474

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

475

2

        &app,

476

2

        &validator,

477

2

&[

478

2

            initial_coin(inj_to_swap, INJ_2, Decimals::Eighteen),

479

2

            initial_coin("1", INJ, Decimals::Eighteen),

480

2

],

481

2

);

482

2

483

2

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

484

2

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

485

486

2

    let query_result: SwapEstimationResult = wasm

487

2

        .query(

488

2

            &contr_addr,

489

2

            &QueryMsg::GetInputQuantity {

490

2

                source_denom: INJ_2.to_string(),

491

2

                target_denom: ETH.to_string(),

492

2

                to_quantity: exact_quantity_to_receive,

493

2

},

494

2

495

2

        .unwrap();

496

2

497

2

    wasm.execute(

498

2

        &contr_addr,

499

2

        &ExecuteMsg::SwapExactOutput {

500

2

            target_denom: ETH.to_string(),

501

2

            target_output_quantity: exact_quantity_to_receive,

502

2

},

503

2

        &[str_coin(inj_to_swap, INJ_2, Decimals::Eighteen)],

504

2

        &swapper,

505

2

506

2

    .unwrap();

507

2

508

2

    let expected_difference = human_to_dec(inj_to_swap, Decimals::Eighteen) - query_result.result_quantity;

509

2

    let swapper_inj_balance_after = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

510

2

    let swapper_atom_balance_after = query_bank_balance(&bank, ETH, swapper.address().as_str());

511

2

512

2

    assert_eq!(swapper_inj_balance_after, expected_difference, "wrong amount of INJ was exchanged");

513

514

2

    assert!(

515

2

        swapper_atom_balance_after >= exact_quantity_to_receive,

516

        "swapper got less than exact amount required -> expected: {} ETH, actual: {} ETH",

517

        exact_quantity_to_receive.scaled(Decimals::Eighteen.get_decimals().neg()),

518

        swapper_atom_balance_after.scaled(Decimals::Eighteen.get_decimals().neg())

519

);

520

521

2

    let max_diff_percent = Percent("0");

522

2

    let one_percent_diff = exact_quantity_to_receive * (FPDecimal::must_from_str(max_diff_percent.0) / FPDecimal::from(100u128));

523

2

524

2

    assert!(

525

2

        are_fpdecimals_approximately_equal(swapper_atom_balance_after, exact_quantity_to_receive, one_percent_diff,),

526

        "swapper did not receive expected exact ETH amount +/- {}% -> expected: {} ETH, actual: {} ETH, max diff: {} ETH",

527

        max_diff_percent.0,

528

        exact_quantity_to_receive.scaled(Decimals::Eighteen.get_decimals().neg()),

529

        swapper_atom_balance_after.scaled(Decimals::Eighteen.get_decimals().neg()),

530

        one_percent_diff.scaled(Decimals::Eighteen.get_decimals().neg())

531

);

532

533

2

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

534

2

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

535

536

2

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

537

2

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

538

2

539

2

    assert!(

540

2

        contract_usdt_balance_after >= contract_usdt_balance_before,

541

        "Contract lost some money after swap. Actual balance: {contract_usdt_balance_after}, previous balance: {contract_usdt_balance_before}",

542

);

543

544

    // contract is allowed to earn extra 1.6 USDT from the swap of ~$23500 worth of INJ

545

2

    let max_diff = human_to_dec("1.6", Decimals::Six);

546

2

547

2

    assert!(

548

2

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

549

        "Contract balance changed too much. Actual balance: {} USDT, previous balance: {} USDT. Max diff: {} USDT",

550

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

551

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

552

        max_diff.scaled(Decimals::Six.get_decimals().neg())

553

);

554

2

555

556

#[test]

557

2

fn it_correctly_swaps_between_markets_using_different_quote_assets_self_relaying() {

558

2

    let app = InjectiveTestApp::new();

559

2

    let wasm = Wasm::new(&app);

560

2

    let exchange = Exchange::new(&app);

561

2

    let bank = Bank::new(&app);

562

2

563

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

564

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

565

2

566

2

    let owner = must_init_account_with_funds_and_setting_denoms(

567

2

        &app,

568

2

        &validator,

569

2

&[

570

2

            initial_coin("1_000", USDT, Decimals::Six),

571

2

            initial_coin("1_000", USDC, Decimals::Six),

572

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

573

2

            initial_coin("1", INJ_2, Decimals::Eighteen),

574

2

],

575

2

);

576

2

577

2

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

578

2

    let spot_market_2_id = launch_realistic_usdt_usdc_spot_market(&exchange, &owner);

579

2

580

2

    let contr_addr = init_self_relaying_contract_and_get_address(

581

2

        &wasm,

582

2

        &owner,

583

2

        &[str_coin("10", USDC, Decimals::Six), str_coin("500", USDT, Decimals::Six)],

584

2

);

585

2

    set_route_and_assert_success(

586

2

        &wasm,

587

2

        &owner,

588

2

        &contr_addr,

589

2

        INJ_2,

590

2

        USDC,

591

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

592

2

);

593

2

594

2

    let trader1 = init_rich_account(&app);

595

2

    let trader2 = init_rich_account(&app);

596

2

597

2

    create_realistic_inj_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

598

2

    create_realistic_usdt_usdc_both_side_orders(&app, &spot_market_2_id, &trader1);

599

2

600

2

    app.increase_time(1);

601

2

602

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

603

2

        &app,

604

2

        &validator,

605

2

        &[initial_coin("1", INJ, Decimals::Eighteen), initial_coin("1", INJ_2, Decimals::Eighteen)],

606

2

);

607

2

608

2

    let inj_to_swap = "1";

609

2

    let to_output_quantity = human_to_dec("8", Decimals::Six);

610

2

611

2

    let mut query_result: SwapEstimationResult = wasm

612

2

        .query(

613

2

            &contr_addr,

614

2

            &QueryMsg::GetInputQuantity {

615

2

                to_quantity: to_output_quantity,

616

2

                source_denom: INJ_2.to_string(),

617

2

                target_denom: USDC.to_string(),

618

2

},

619

2

620

2

        .unwrap();

621

2

622

2

    let expected_input_quantity = human_to_dec("0.903", Decimals::Eighteen);

623

2

    let max_diff = human_to_dec("0.001", Decimals::Eighteen);

624

2

625

2

    assert!(

626

2

        are_fpdecimals_approximately_equal(expected_input_quantity, query_result.result_quantity, max_diff),

627

        "incorrect swap result estimate returned by query. Expected: {} INJ, actual: {} INJ, max diff: {} INJ",

628

        expected_input_quantity.scaled(Decimals::Eighteen.get_decimals().neg()),

629

        query_result.result_quantity.scaled(Decimals::Eighteen.get_decimals().neg()),

630

        max_diff.scaled(Decimals::Eighteen.get_decimals().neg())

631

);

632

633

2

    let mut expected_fees = vec![

634

2

        FPCoin {

635

2

            amount: human_to_dec("0.013365", Decimals::Six),

636

2

            denom: USDT.to_string(),

637

2

},

638

2

        FPCoin {

639

2

            amount: human_to_dec("0.01332", Decimals::Six),

640

2

            denom: USDC.to_string(),

641

2

},

642

2

];

643

2

644

2

    // we don't care too much about decimal fraction of the fee

645

2

    assert_fee_is_as_expected(&mut query_result.expected_fees, &mut expected_fees, human_to_dec("0.1", Decimals::Six));

646

2

647

2

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

648

2

    assert_eq!(contract_balances_before.len(), 2, "wrong number of denoms in contract balances");

649

650

2

    wasm.execute(

651

2

        &contr_addr,

652

2

        &ExecuteMsg::SwapExactOutput {

653

2

            target_denom: USDC.to_string(),

654

2

            target_output_quantity: to_output_quantity,

655

2

},

656

2

        &[str_coin(inj_to_swap, INJ_2, Decimals::Eighteen)],

657

2

        &swapper,

658

2

659

2

    .unwrap();

660

2

661

2

    let from_balance = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

662

2

    let to_balance = query_bank_balance(&bank, USDC, swapper.address().as_str());

663

2

664

2

    let expected_inj_leftover = human_to_dec(inj_to_swap, Decimals::Eighteen) - expected_input_quantity;

665

2

    assert_eq!(from_balance, expected_inj_leftover, "incorrect original amount was left after swap");

666

667

2

    let expected_amount = human_to_dec("8.00711", Decimals::Six);

668

2

669

2

    assert_eq!(

670

        to_balance,

671

        expected_amount,

672

        "Swapper received less than expected minimum amount. Expected: {} USDC, actual: {} USDC",

673

        expected_amount.scaled(Decimals::Six.get_decimals().neg()),

674

        to_balance.scaled(Decimals::Six.get_decimals().neg()),

675

);

676

677

2

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

678

2

    assert_eq!(contract_balances_after.len(), 2, "wrong number of denoms in contract balances");

679

680

    // let's check contract's USDT balance

681

2

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

682

2

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

683

2

684

2

    assert!(

685

2

        contract_usdt_balance_after >= contract_usdt_balance_before,

686

        "Contract lost some money after swap. Actual balance: {} USDT, previous balance: {} USDT",

687

        contract_usdt_balance_after,

688

        contract_usdt_balance_before

689

);

690

691

    // contract is allowed to earn extra 0.001 USDT from the swap of ~$8 worth of INJ

692

2

    let max_diff = human_to_dec("0.001", Decimals::Six);

693

2

694

2

    assert!(

695

2

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

696

        "Contract balance changed too much. Actual balance: {} USDT, previous balance: {} USDT. Max diff: {} USDT",

697

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

698

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

699

        max_diff.scaled(Decimals::Six.get_decimals().neg())

700

);

701

702

    // let's check contract's USDC balance

703

2

    let contract_usdc_balance_before = FPDecimal::must_from_str(contract_balances_before[1].amount.as_str());

704

2

    let contract_usdc_balance_after = FPDecimal::must_from_str(contract_balances_after[1].amount.as_str());

705

2

706

2

    assert!(

707

2

        contract_usdc_balance_after >= contract_usdc_balance_before,

708

        "Contract lost some money after swap. Actual balance: {} USDC, previous balance: {} USDC",

709

        contract_usdc_balance_after,

710

        contract_usdc_balance_before

711

);

712

713

    // contract is allowed to earn extra 0.001 USDC from the swap of ~$8 worth of INJ

714

2

    let max_diff = human_to_dec("0.001", Decimals::Six);

715

2

716

2

    assert!(

717

2

        are_fpdecimals_approximately_equal(contract_usdc_balance_after, contract_usdc_balance_before, max_diff,),

718

        "Contract balance changed too much. Actual balance: {} USDC, previous balance: {} USDC. Max diff: {} USDC",

719

        contract_usdc_balance_after.scaled(Decimals::Six.get_decimals().neg()),

720

        contract_usdc_balance_before.scaled(Decimals::Six.get_decimals().neg()),

721

        max_diff.scaled(Decimals::Six.get_decimals().neg())

722

);

723

2

724

725

#[test]

726

2

fn it_correctly_swaps_between_markets_using_different_quote_assets_self_relaying_ninja() {

727

2

    let app = InjectiveTestApp::new();

728

2

    let wasm = Wasm::new(&app);

729

2

    let exchange = Exchange::new(&app);

730

2

    let bank = Bank::new(&app);

731

2

732

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

733

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

734

2

735

2

    let owner = must_init_account_with_funds_and_setting_denoms(

736

2

        &app,

737

2

        &validator,

738

2

&[

739

2

            initial_coin("1_000", USDT, Decimals::Six),

740

2

            initial_coin("1_000", USDC, Decimals::Six),

741

2

            initial_coin("1_000", NINJA, Decimals::Six),

742

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

743

2

            initial_coin("101", INJ_2, Decimals::Eighteen),

744

2

],

745

2

);

746

2

747

2

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

748

2

    let spot_market_2_id = launch_realistic_ninja_inj_spot_market(&exchange, &owner);

749

2

750

2

    let contr_addr = init_self_relaying_contract_and_get_address(

751

2

        &wasm,

752

2

        &owner,

753

2

&[

754

2

            str_coin("100", INJ_2, Decimals::Eighteen),

755

2

            str_coin("10", USDC, Decimals::Six),

756

2

            str_coin("500", USDT, Decimals::Six),

757

2

],

758

2

);

759

2

    set_route_and_assert_success(

760

2

        &wasm,

761

2

        &owner,

762

2

        &contr_addr,

763

2

        USDT,

764

2

        NINJA,

765

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

766

2

);

767

2

768

2

    let trader1 = init_rich_account(&app);

769

2

770

2

    create_realistic_inj_usdt_sell_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1);

771

2

    create_ninja_inj_both_side_orders(&app, &spot_market_2_id, &trader1);

772

2

773

2

    app.increase_time(1);

774

2

775

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

776

2

        &app,

777

2

        &validator,

778

2

        &[initial_coin("1", INJ, Decimals::Eighteen), initial_coin("100000", USDT, Decimals::Six)],

779

2

);

780

2

781

2

    let usdt_to_swap = "100000";

782

2

    let to_output_quantity = human_to_dec("501000", Decimals::Six);

783

2

784

2

    let from_balance_before = query_bank_balance(&bank, USDT, swapper.address().as_str());

785

2

    let to_balance_before = query_bank_balance(&bank, NINJA, swapper.address().as_str());

786

2

787

2

    wasm.execute(

788

2

        &contr_addr,

789

2

        &ExecuteMsg::SwapExactOutput {

790

2

            target_denom: NINJA.to_string(),

791

2

            target_output_quantity: to_output_quantity,

792

2

},

793

2

        &[str_coin(usdt_to_swap, USDT, Decimals::Six)],

794

2

        &swapper,

795

2

796

2

    .unwrap();

797

2

798

2

    let from_balance_after = query_bank_balance(&bank, USDT, swapper.address().as_str());

799

2

    let to_balance_after = query_bank_balance(&bank, NINJA, swapper.address().as_str());

800

2

801

2

    // from 100000 USDT -> 96201.062127 USDT = 3798.937872 USDT

802

2

    let expected_from_balance_before = human_to_dec("100000", Decimals::Six);

803

2

    let expected_from_balance_after = human_to_dec("96201.062127", Decimals::Six);

804

2

805

2

    // from 0 NINJA to 501000 NINJA

806

2

    let expected_to_balance_before = human_to_dec("0", Decimals::Six);

807

2

    let expected_to_balance_after = human_to_dec("501000", Decimals::Six);

808

2

809

2

    assert_eq!(

810

        from_balance_before, expected_from_balance_before,

811

        "incorrect original amount was left after swap"

812

);

813

2

    assert_eq!(to_balance_before, expected_to_balance_before, "incorrect target amount after swap");

814

2

    assert_eq!(

815

        from_balance_after, expected_from_balance_after,

816

        "incorrect original amount was left after swap"

817

);

818

2

    assert_eq!(to_balance_after, expected_to_balance_after, "incorrect target amount after swap");

819

2

820

821

#[test]

822

2

fn it_doesnt_lose_buffer_if_exact_swap_of_eth_to_atom_is_executed_multiple_times() {

823

2

    let app = InjectiveTestApp::new();

824

2

    let wasm = Wasm::new(&app);

825

2

    let exchange = Exchange::new(&app);

826

2

    let bank = Bank::new(&app);

827

2

828

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

829

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

830

2

831

2

    let owner = must_init_account_with_funds_and_setting_denoms(

832

2

        &app,

833

2

        &validator,

834

2

&[

835

2

            initial_coin("1", ETH, Decimals::Eighteen),

836

2

            initial_coin("1", ATOM, Decimals::Six),

837

2

            initial_coin("1_000", USDT, Decimals::Six),

838

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

839

2

],

840

2

);

841

2

842

2

    let spot_market_1_id = launch_realistic_weth_usdt_spot_market(&exchange, &owner);

843

2

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

844

2

845

2

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

846

2

847

2

    set_route_and_assert_success(

848

2

        &wasm,

849

2

        &owner,

850

2

        &contr_addr,

851

2

        ETH,

852

2

        ATOM,

853

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

854

2

);

855

2

856

2

    let trader1 = init_rich_account(&app);

857

2

    let trader2 = init_rich_account(&app);

858

2

    let trader3 = init_rich_account(&app);

859

2

860

2

    let eth_to_swap = "4.08";

861

2

    let iterations = 100i128;

862

2

863

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

864

2

        &app,

865

2

        &validator,

866

2

&[

867

2

            initial_coin(

868

2

                (FPDecimal::must_from_str(eth_to_swap) * FPDecimal::from(iterations)).to_string().as_str(),

869

2

                ETH,

870

2

                Decimals::Eighteen,

871

2

),

872

2

            initial_coin("1", INJ, Decimals::Eighteen),

873

2

],

874

2

);

875

2

876

2

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

877

2

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

878

879

2

    let mut counter = 0;

880

881

202

    while counter < iterations {

882

200

        create_realistic_eth_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

883

200

        create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

884

200

885

200

        app.increase_time(1);

886

200

887

200

        wasm.execute(

888

200

            &contr_addr,

889

200

            &ExecuteMsg::SwapExactOutput {

890

200

                target_denom: ATOM.to_string(),

891

200

                target_output_quantity: human_to_dec("906", Decimals::Six),

892

200

},

893

200

            &[str_coin(eth_to_swap, ETH, Decimals::Eighteen)],

894

200

            &swapper,

895

200

896

200

        .unwrap();

897

200

898

200

        counter += 1

899

900

901

2

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

902

2

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

903

904

2

    let contract_balance_usdt_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

905

2

    let contract_balance_usdt_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

906

2

907

2

    assert!(

908

2

        contract_balance_usdt_after >= contract_balance_usdt_before,

909

        "Contract lost some money after swap. Starting balance: {contract_balance_usdt_after}, Current balance: {contract_balance_usdt_before}",

910

);

911

912

    // single swap with the same values results in < 0.7 USDT earning, so we expected that 100 same swaps

913

    // won't change balance by more than 0.7 * 100 = 70 USDT

914

2

    let max_diff = human_to_dec("0.7", Decimals::Six) * FPDecimal::from(iterations);

915

2

916

2

    assert!(

917

2

        are_fpdecimals_approximately_equal(contract_balance_usdt_after, contract_balance_usdt_before, max_diff,),

918

        "Contract balance changed too much. Starting balance: {}, Current balance: {}. Max diff: {}",

919

        contract_balance_usdt_before.scaled(Decimals::Six.get_decimals().neg()),

920

        contract_balance_usdt_after.scaled(Decimals::Six.get_decimals().neg()),

921

        max_diff.scaled(Decimals::Six.get_decimals().neg())

922

);

923

2

924

925

#[test]

926

2

fn it_reverts_when_funds_provided_are_below_required_to_get_exact_amount() {

927

2

    let app = InjectiveTestApp::new();

928

2

    let wasm = Wasm::new(&app);

929

2

    let exchange = Exchange::new(&app);

930

2

    let bank = Bank::new(&app);

931

2

932

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

933

2

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

934

2

935

2

    let owner = must_init_account_with_funds_and_setting_denoms(

936

2

        &app,

937

2

        &validator,

938

2

&[

939

2

            initial_coin("1", ETH, Decimals::Eighteen),

940

2

            initial_coin("1", ATOM, Decimals::Six),

941

2

            initial_coin("1_000", USDT, Decimals::Six),

942

2

            initial_coin("10_000", INJ, Decimals::Eighteen),

943

2

            initial_coin("10_000", INJ_2, Decimals::Eighteen),

944

2

],

945

2

);

946

2

947

2

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

948

2

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

949

2

950

2

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

951

2

    set_route_and_assert_success(

952

2

        &wasm,

953

2

        &owner,

954

2

        &contr_addr,

955

2

        INJ_2,

956

2

        ATOM,

957

2

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

958

2

);

959

2

960

2

    let trader1 = init_rich_account(&app);

961

2

    let trader2 = init_rich_account(&app);

962

2

    let trader3 = init_rich_account(&app);

963

2

964

2

    create_realistic_inj_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

965

2

    create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

966

2

967

2

    app.increase_time(1);

968

2

969

2

    let inj_to_swap = "608";

970

2

971

2

    let swapper = must_init_account_with_funds_and_setting_denoms(

972

2

        &app,

973

2

        &validator,

974

2

&[

975

2

            initial_coin(inj_to_swap, INJ_2, Decimals::Eighteen),

976

2

            initial_coin("1", INJ, Decimals::Eighteen),

977

2

],

978

2

);

979

2

980

2

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

981

2

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

982

983

2

    let exact_quantity_to_receive = human_to_dec("600", Decimals::Six);

984

2

    let swapper_inj_balance_before = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

985

2

986

2

    let _: SwapEstimationResult = wasm

987

2

        .query(

988

2

            &contr_addr,

989

2

            &QueryMsg::GetInputQuantity {

990

2

                source_denom: INJ_2.to_string(),

991

2

                target_denom: ATOM.to_string(),

992

2

                to_quantity: exact_quantity_to_receive,

993

2

},

994

2

995

2

        .unwrap();

996

2

997

2

    let execute_result = wasm

998

2

        .execute(

999

2

            &contr_addr,

1000

2

            &ExecuteMsg::SwapExactOutput {

1001

2

                target_denom: ATOM.to_string(),

1002

2

                target_output_quantity: exact_quantity_to_receive,

1003

2

},

1004

2

            &[str_coin(inj_to_swap, INJ_2, Decimals::Eighteen)],

1005

2

            &swapper,

1006

2

1007

2

        .unwrap_err();

1008

2

1009

2

    assert!(

1010

2

        execute_result

1011

2

            .to_string()

1012

2

            .contains("Provided amount of 608000000000000000000 is below required amount of 609714000000000000000"),

1013

        "wrong error message"

1014

);

1015

1016

2

    let swapper_inj_balance_after = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

1017

2

    let swapper_atom_balance_after = query_bank_balance(&bank, ATOM, swapper.address().as_str());

1018

2

1019

2

    assert_eq!(swapper_inj_balance_before, swapper_inj_balance_after, "some amount of INJ was exchanged");

1020

1021

2

    assert_eq!(FPDecimal::ZERO, swapper_atom_balance_after, "swapper received some ATOM");

1022

1023

2

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

1024

2

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

1025

1026

2

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

1027

2

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

1028

2

1029

2

    assert_eq!(

1030

        contract_usdt_balance_after, contract_usdt_balance_before,

1031

        "Contract's balance changed after failed swap",

1032

);

1033

2

1034

1035

// TEST TEMPLATES

1036

1037

// source much more expensive than target

1038

10

fn exact_two_hop_eth_atom_swap_test_template(exact_quantity_to_receive: FPDecimal, max_diff_percentage: Percent) {

1039

10

    let app = InjectiveTestApp::new();

1040

10

    let wasm = Wasm::new(&app);

1041

10

    let exchange = Exchange::new(&app);

1042

10

    let bank = Bank::new(&app);

1043

10

1044

10

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

1045

10

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

1046

10

1047

10

    let owner = must_init_account_with_funds_and_setting_denoms(

1048

10

        &app,

1049

10

        &validator,

1050

10

&[

1051

10

            initial_coin("1", ETH, Decimals::Eighteen),

1052

10

            initial_coin("1", ATOM, Decimals::Six),

1053

10

            initial_coin("1_000", USDT, Decimals::Six),

1054

10

            initial_coin("10_000", INJ, Decimals::Eighteen),

1055

10

],

1056

10

);

1057

10

1058

10

    let spot_market_1_id = launch_realistic_weth_usdt_spot_market(&exchange, &owner);

1059

10

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

1060

10

1061

10

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

1062

10

    set_route_and_assert_success(

1063

10

        &wasm,

1064

10

        &owner,

1065

10

        &contr_addr,

1066

10

        ETH,

1067

10

        ATOM,

1068

10

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

1069

10

);

1070

10

1071

10

    let trader1 = init_rich_account(&app);

1072

10

    let trader2 = init_rich_account(&app);

1073

10

    let trader3 = init_rich_account(&app);

1074

10

1075

10

    create_realistic_eth_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

1076

10

    create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

1077

10

1078

10

    app.increase_time(1);

1079

10

1080

10

    let eth_to_swap = "4.08";

1081

10

1082

10

    let swapper = must_init_account_with_funds_and_setting_denoms(

1083

10

        &app,

1084

10

        &validator,

1085

10

&[

1086

10

            initial_coin(eth_to_swap, ETH, Decimals::Eighteen),

1087

10

            initial_coin("1", INJ, Decimals::Eighteen),

1088

10

],

1089

10

);

1090

10

1091

10

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

1092

10

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

1093

1094

10

    let query_result: SwapEstimationResult = wasm

1095

10

        .query(

1096

10

            &contr_addr,

1097

10

            &QueryMsg::GetInputQuantity {

1098

10

                source_denom: ETH.to_string(),

1099

10

                target_denom: ATOM.to_string(),

1100

10

                to_quantity: exact_quantity_to_receive,

1101

10

},

1102

10

1103

10

        .unwrap();

1104

10

1105

10

    wasm.execute(

1106

10

        &contr_addr,

1107

10

        &ExecuteMsg::SwapExactOutput {

1108

10

            target_denom: ATOM.to_string(),

1109

10

            target_output_quantity: exact_quantity_to_receive,

1110

10

},

1111

10

        &[str_coin(eth_to_swap, ETH, Decimals::Eighteen)],

1112

10

        &swapper,

1113

10

1114

10

    .unwrap();

1115

10

1116

10

    let expected_difference = human_to_dec(eth_to_swap, Decimals::Eighteen) - query_result.result_quantity;

1117

10

    let swapper_eth_balance_after = query_bank_balance(&bank, ETH, swapper.address().as_str());

1118

10

    let swapper_atom_balance_after = query_bank_balance(&bank, ATOM, swapper.address().as_str());

1119

10

1120

10

    assert_eq!(swapper_eth_balance_after, expected_difference, "wrong amount of ETH was exchanged");

1121

1122

10

    let one_percent_diff = exact_quantity_to_receive * (FPDecimal::must_from_str(max_diff_percentage.0) / FPDecimal::from(100u128));

1123

10

1124

10

    assert!(

1125

10

        swapper_atom_balance_after >= exact_quantity_to_receive,

1126

        "swapper got less than exact amount required -> expected: {} ATOM, actual: {} ATOM",

1127

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

1128

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg())

1129

);

1130

1131

10

    assert!(

1132

10

        are_fpdecimals_approximately_equal(swapper_atom_balance_after, exact_quantity_to_receive, one_percent_diff,),

1133

        "swapper did not receive expected exact amount +/- {}% -> expected: {} ATOM, actual: {} ATOM, max diff: {} ATOM",

1134

        max_diff_percentage.0,

1135

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

1136

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg()),

1137

        one_percent_diff.scaled(Decimals::Six.get_decimals().neg())

1138

);

1139

1140

10

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

1141

10

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

1142

1143

10

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

1144

10

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

1145

10

1146

10

    assert!(

1147

10

        contract_usdt_balance_after >= contract_usdt_balance_before,

1148

        "Contract lost some money after swap. Actual balance: {contract_usdt_balance_after}, previous balance: {contract_usdt_balance_before}",

1149

);

1150

1151

    // contract is allowed to earn extra 0.7 USDT from the swap of ~$8150 worth of ETH

1152

10

    let max_diff = human_to_dec("0.7", Decimals::Six);

1153

10

1154

10

    assert!(

1155

10

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

1156

        "Contract balance changed too much. Actual balance: {} USDT, previous balance: {} USDT. Max diff: {} USDT",

1157

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

1158

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

1159

        max_diff.scaled(Decimals::Six.get_decimals().neg())

1160

);

1161

10

1162

1163

// source more or less similarly priced as target

1164

10

fn exact_two_hop_inj_atom_swap_test_template(exact_quantity_to_receive: FPDecimal, max_diff_percentage: Percent) {

1165

10

    let app = InjectiveTestApp::new();

1166

10

    let wasm = Wasm::new(&app);

1167

10

    let exchange = Exchange::new(&app);

1168

10

    let bank = Bank::new(&app);

1169

10

1170

10

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

1171

10

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

1172

10

1173

10

    let owner = must_init_account_with_funds_and_setting_denoms(

1174

10

        &app,

1175

10

        &validator,

1176

10

&[

1177

10

            initial_coin("1", ETH, Decimals::Eighteen),

1178

10

            initial_coin("1", ATOM, Decimals::Six),

1179

10

            initial_coin("1_000", USDT, Decimals::Six),

1180

10

            initial_coin("10_000", INJ, Decimals::Eighteen),

1181

10

            initial_coin("10_000", INJ_2, Decimals::Eighteen),

1182

10

],

1183

10

);

1184

10

1185

10

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

1186

10

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

1187

10

1188

10

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

1189

10

    set_route_and_assert_success(

1190

10

        &wasm,

1191

10

        &owner,

1192

10

        &contr_addr,

1193

10

        INJ_2,

1194

10

        ATOM,

1195

10

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

1196

10

);

1197

10

1198

10

    let trader1 = init_rich_account(&app);

1199

10

    let trader2 = init_rich_account(&app);

1200

10

    let trader3 = init_rich_account(&app);

1201

10

1202

10

    create_realistic_inj_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

1203

10

    create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

1204

10

1205

10

    app.increase_time(1);

1206

10

1207

10

    let inj_to_swap = "973.258";

1208

10

1209

10

    let swapper = must_init_account_with_funds_and_setting_denoms(

1210

10

        &app,

1211

10

        &validator,

1212

10

&[

1213

10

            initial_coin(inj_to_swap, INJ_2, Decimals::Eighteen),

1214

10

            initial_coin("1", INJ, Decimals::Eighteen),

1215

10

],

1216

10

);

1217

10

1218

10

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

1219

10

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

1220

1221

10

    let query_result: SwapEstimationResult = wasm

1222

10

        .query(

1223

10

            &contr_addr,

1224

10

            &QueryMsg::GetInputQuantity {

1225

10

                source_denom: INJ_2.to_string(),

1226

10

                target_denom: ATOM.to_string(),

1227

10

                to_quantity: exact_quantity_to_receive,

1228

10

},

1229

10

1230

10

        .unwrap();

1231

10

1232

10

    wasm.execute(

1233

10

        &contr_addr,

1234

10

        &ExecuteMsg::SwapExactOutput {

1235

10

            target_denom: ATOM.to_string(),

1236

10

            target_output_quantity: exact_quantity_to_receive,

1237

10

},

1238

10

        &[str_coin(inj_to_swap, INJ_2, Decimals::Eighteen)],

1239

10

        &swapper,

1240

10

1241

10

    .unwrap();

1242

10

1243

10

    let expected_difference = human_to_dec(inj_to_swap, Decimals::Eighteen) - query_result.result_quantity;

1244

10

    let swapper_inj_balance_after = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

1245

10

    let swapper_atom_balance_after = query_bank_balance(&bank, ATOM, swapper.address().as_str());

1246

10

1247

10

    assert_eq!(swapper_inj_balance_after, expected_difference, "wrong amount of INJ was exchanged");

1248

1249

10

    assert!(

1250

10

        swapper_atom_balance_after >= exact_quantity_to_receive,

1251

        "swapper got less than exact amount required -> expected: {} ATOM, actual: {} ATOM",

1252

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

1253

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg())

1254

);

1255

1256

10

    let one_percent_diff = exact_quantity_to_receive * (FPDecimal::must_from_str(max_diff_percentage.0) / FPDecimal::from(100u128));

1257

10

1258

10

    assert!(

1259

10

        are_fpdecimals_approximately_equal(swapper_atom_balance_after, exact_quantity_to_receive, one_percent_diff,),

1260

        "swapper did not receive expected exact ATOM amount +/- {}% -> expected: {} ATOM, actual: {} ATOM, max diff: {} ATOM",

1261

        max_diff_percentage.0,

1262

        exact_quantity_to_receive.scaled(Decimals::Six.get_decimals().neg()),

1263

        swapper_atom_balance_after.scaled(Decimals::Six.get_decimals().neg()),

1264

        one_percent_diff.scaled(Decimals::Six.get_decimals().neg())

1265

);

1266

1267

10

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

1268

10

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

1269

1270

10

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

1271

10

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

1272

10

1273

10

    assert!(

1274

10

        contract_usdt_balance_after >= contract_usdt_balance_before,

1275

        "Contract lost some money after swap. Actual balance: {contract_usdt_balance_after}, previous balance: {contract_usdt_balance_before}",

1276

);

1277

1278

    // contract is allowed to earn extra 0.7 USDT from the swap of ~$8150 worth of INJ

1279

10

    let max_diff = human_to_dec("0.7", Decimals::Six);

1280

10

1281

10

    assert!(

1282

10

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

1283

        "Contract balance changed too much. Actual balance: {} USDT, previous balance: {} USDT. Max diff: {} USDT",

1284

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

1285

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

1286

        max_diff.scaled(Decimals::Six.get_decimals().neg())

1287

);

1288

10

1289

1290

// source much cheaper than target

1291

8

fn exact_two_hop_inj_eth_swap_test_template(exact_quantity_to_receive: FPDecimal, max_diff_percentage: Percent) {

1292

8

    let app = InjectiveTestApp::new();

1293

8

    let wasm = Wasm::new(&app);

1294

8

    let exchange = Exchange::new(&app);

1295

8

    let bank = Bank::new(&app);

1296

8

1297

8

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

1298

8

    let _signer = must_init_account_with_funds_and_setting_denoms(&app, &validator, &[initial_coin("1", INJ, Decimals::Eighteen)]);

1299

8

1300

8

    let owner = must_init_account_with_funds_and_setting_denoms(

1301

8

        &app,

1302

8

        &validator,

1303

8

&[

1304

8

            initial_coin("1", ETH, Decimals::Eighteen),

1305

8

            initial_coin("1_000", USDT, Decimals::Six),

1306

8

            initial_coin("10_000", INJ, Decimals::Eighteen),

1307

8

            initial_coin("10_000", INJ_2, Decimals::Eighteen),

1308

8

],

1309

8

);

1310

8

1311

8

    let spot_market_1_id = launch_realistic_inj_usdt_spot_market(&exchange, &owner);

1312

8

    let spot_market_2_id = launch_realistic_weth_usdt_spot_market(&exchange, &owner);

1313

8

1314

8

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

1315

8

    set_route_and_assert_success(

1316

8

        &wasm,

1317

8

        &owner,

1318

8

        &contr_addr,

1319

8

        INJ_2,

1320

8

        ETH,

1321

8

        vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

1322

8

);

1323

8

1324

8

    let trader1 = init_rich_account(&app);

1325

8

    let trader2 = init_rich_account(&app);

1326

8

    let trader3 = init_rich_account(&app);

1327

8

1328

8

    create_realistic_inj_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

1329

8

    create_realistic_eth_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

1330

8

1331

8

    app.increase_time(1);

1332

8

1333

8

    let inj_to_swap = "973.258";

1334

8

1335

8

    let swapper = must_init_account_with_funds_and_setting_denoms(

1336

8

        &app,

1337

8

        &validator,

1338

8

&[

1339

8

            initial_coin(inj_to_swap, INJ_2, Decimals::Eighteen),

1340

8

            initial_coin("1", INJ, Decimals::Eighteen),

1341

8

],

1342

8

);

1343

8

1344

8

    let contract_balances_before = query_all_bank_balances(&bank, &contr_addr);

1345

8

    assert_eq!(contract_balances_before.len(), 1, "wrong number of denoms in contract balances");

1346

1347

8

    let query_result: SwapEstimationResult = wasm

1348

8

        .query(

1349

8

            &contr_addr,

1350

8

            &QueryMsg::GetInputQuantity {

1351

8

                source_denom: INJ_2.to_string(),

1352

8

                target_denom: ETH.to_string(),

1353

8

                to_quantity: exact_quantity_to_receive,

1354

8

},

1355

8

1356

8

        .unwrap();

1357

8

1358

8

    wasm.execute(

1359

8

        &contr_addr,

1360

8

        &ExecuteMsg::SwapExactOutput {

1361

8

            target_denom: ETH.to_string(),

1362

8

            target_output_quantity: exact_quantity_to_receive,

1363

8

},

1364

8

        &[str_coin(inj_to_swap, INJ_2, Decimals::Eighteen)],

1365

8

        &swapper,

1366

8

1367

8

    .unwrap();

1368

8

1369

8

    let expected_difference = human_to_dec(inj_to_swap, Decimals::Eighteen) - query_result.result_quantity;

1370

8

    let swapper_inj_balance_after = query_bank_balance(&bank, INJ_2, swapper.address().as_str());

1371

8

    let swapper_atom_balance_after = query_bank_balance(&bank, ETH, swapper.address().as_str());

1372

8

1373

8

    assert_eq!(swapper_inj_balance_after, expected_difference, "wrong amount of INJ was exchanged");

1374

1375

8

    assert!(

1376

8

        swapper_atom_balance_after >= exact_quantity_to_receive,

1377

        "swapper got less than exact amount required -> expected: {} ETH, actual: {} ETH",

1378

        exact_quantity_to_receive.scaled(Decimals::Eighteen.get_decimals().neg()),

1379

        swapper_atom_balance_after.scaled(Decimals::Eighteen.get_decimals().neg())

1380

);

1381

1382

8

    let one_percent_diff = exact_quantity_to_receive * (FPDecimal::must_from_str(max_diff_percentage.0) / FPDecimal::from(100u128));

1383

8

1384

8

    assert!(

1385

8

        are_fpdecimals_approximately_equal(swapper_atom_balance_after, exact_quantity_to_receive, one_percent_diff,),

1386

        "swapper did not receive expected exact ETH amount +/- {}% -> expected: {} ETH, actual: {} ETH, max diff: {} ETH",

1387

        max_diff_percentage.0,

1388

        exact_quantity_to_receive.scaled(Decimals::Eighteen.get_decimals().neg()),

1389

        swapper_atom_balance_after.scaled(Decimals::Eighteen.get_decimals().neg()),

1390

        one_percent_diff.scaled(Decimals::Eighteen.get_decimals().neg())

1391

);

1392

1393

8

    let contract_balances_after = query_all_bank_balances(&bank, contr_addr.as_str());

1394

8

    assert_eq!(contract_balances_after.len(), 1, "wrong number of denoms in contract balances");

1395

1396

8

    let contract_usdt_balance_before = FPDecimal::must_from_str(contract_balances_before[0].amount.as_str());

1397

8

    let contract_usdt_balance_after = FPDecimal::must_from_str(contract_balances_after[0].amount.as_str());

1398

8

1399

8

    assert!(

1400

8

        contract_usdt_balance_after >= contract_usdt_balance_before,

1401

        "Contract lost some money after swap. Actual balance: {contract_usdt_balance_after}, previous balance: {contract_usdt_balance_before}",

1402

);

1403

1404

    // contract is allowed to earn extra 0.7 USDT from the swap of ~$8500 worth of INJ

1405

8

    let max_diff = human_to_dec("0.82", Decimals::Six);

1406

8

1407

8

    assert!(

1408

8

        are_fpdecimals_approximately_equal(contract_usdt_balance_after, contract_usdt_balance_before, max_diff,),

1409

        "Contract balance changed too much. Actual balance: {} USDT, previous balance: {} USDT. Max diff: {} USDT",

1410

        contract_usdt_balance_after.scaled(Decimals::Six.get_decimals().neg()),

1411

        contract_usdt_balance_before.scaled(Decimals::Six.get_decimals().neg()),

1412

        max_diff.scaled(Decimals::Six.get_decimals().neg())

1413

);

1414

8