monero-wallet 0.2.0

Wallet functionality for the Monero protocol, built around monero-oxide
Documentation 
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

#![expect(missing_docs)]

use monero_oxide::transaction::Transaction;
use monero_simple_request_rpc::{prelude::MoneroDaemon, SimpleRequestTransport};
use monero_wallet::{extra::MAX_ARBITRARY_DATA_SIZE, send::SendError};

mod runner;

type Rpc = MoneroDaemon<SimpleRequestTransport>;

test!(
  add_single_data_less_than_max,
  (
    async |_, mut builder: Builder, addr| {
      let arbitrary_data = vec![b'\0'; MAX_ARBITRARY_DATA_SIZE - 1];

      // make sure we can add to tx
      builder.add_data(arbitrary_data.clone()).unwrap();

      builder.add_payment(addr, 5);
      (builder.build().unwrap(), (arbitrary_data,))
    },
    async |_rpc: Rpc, block, tx: Transaction, mut scanner: Scanner, data: (Vec<u8>,)| {
      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
      assert_eq!(output.transaction(), tx.hash());
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.arbitrary_data()[0], data.0);
    },
  ),
);

test!(
  add_multiple_data_less_than_max,
  (
    async |_, mut builder: Builder, addr| {
      let mut data = vec![];
      for b in 1 ..= 3 {
        data.push(vec![b; MAX_ARBITRARY_DATA_SIZE - 1]);
      }

      // Add data multiple times
      for data in &data {
        builder.add_data(data.clone()).unwrap();
      }

      builder.add_payment(addr, 5);
      (builder.build().unwrap(), data)
    },
    async |_rpc: Rpc, block, tx: Transaction, mut scanner: Scanner, data: Vec<Vec<u8>>| {
      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
      assert_eq!(output.transaction(), tx.hash());
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.arbitrary_data(), data);
    },
  ),
);

test!(
  add_single_data_more_than_max,
  (
    async |_, mut builder: Builder, addr| {
      // Make a data that is bigger than the maximum
      let mut data = vec![b'a'; MAX_ARBITRARY_DATA_SIZE + 1];

      // Make sure we get an error if we try to add it to the TX
      assert_eq!(builder.add_data(data.clone()), Err(SendError::TooMuchArbitraryData));

      // Reduce data size and retry. The data will now be 255 bytes long (including the added
      // marker), exactly
      data.pop();
      builder.add_data(data.clone()).unwrap();

      builder.add_payment(addr, 5);
      (builder.build().unwrap(), data)
    },
    async |_rpc: Rpc, block, tx: Transaction, mut scanner: Scanner, data: Vec<u8>| {
      let output = scanner.scan(block).unwrap().not_additionally_locked().swap_remove(0);
      assert_eq!(output.transaction(), tx.hash());
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.arbitrary_data(), vec![data]);
    },
  ),
);