miden-base-macros 0.13.1

Provides proc macro support for Miden rollup SDK
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
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
127
128
129
130
131
132
133
134

package miden:base@1.0.0;

/// Types to be used in tx-kernel interface
interface core-types {
    /// Represents an on-chain felt.
    ///
    /// Field modulus M = 2^64 - 2^32 + 1.
    record felt {
        /// The backing type is `f32` which will be treated as a felt by the compiler.
	/// We're basically hijacking the Wasm `f32` type and treat as felt.
        inner: f32,
    }


    /// A group of four field elements in the Miden base field.
    record word {
        a: felt,
	b: felt,
	c: felt,
	d: felt,
    }

    /// A cryptographic digest representing a 256-bit hash value.
    /// This is a wrapper around `word` which contains 4 field elements.
    record digest {
        inner: word
    }

    /// Unique identifier of an account.
    ///
    /// # Layout
    ///
    /// An `AccountId` consists of two field elements, where the first is called the prefix and the
    /// second is called the suffix. It is laid out as follows:
    ///
    /// prefix: [hash (56 bits) | storage mode (2 bits) | type (2 bits) | version (4 bits)]
    /// suffix: [zero bit | hash (55 bits) | 8 zero bits]
    record account-id {
    	prefix: felt,
	suffix: felt
    }

    /// Creates a new account ID from a field element.
    //account-id-from-felt: func(felt: felt) -> account-id;

    /// Recipient of the note, i.e., hash(hash(hash(serial_num, [0; 4]), note_script_hash), input_hash)
    record recipient {
        inner: word
    }

    record tag {
        inner: felt
    }

    /// A fungible or a non-fungible asset.
    ///
    /// In protocol v0.14 assets are encoded as two words: an asset key and an asset value.
    ///
    /// The methodology for constructing fungible and non-fungible assets is described below.
    ///
    /// # Fungible assets
    /// - `key`: `[0, 0, faucet_id_suffix, faucet_id_prefix]`
    /// - `value`: `[amount, 0, 0, 0]`
    ///
    /// # Non-fungible assets
    /// - `key`: `[hash0, hash1, faucet_id_suffix, faucet_id_prefix]`
    /// - `value`: `DATA_HASH`
    record asset {
        key: word,
        value: word,
    }

    /// Account nonce
    record nonce {
        inner: felt
    }

    /// Account hash
    record account-hash {
        inner: word
    }

    /// Block hash
    record block-hash {
        inner: word
    }

    /// Storage value
    record storage-value {
        inner: word
    }

    /// Account storage root
    record storage-root {
        inner: word
    }

    /// Account code root
    record account-code-root {
        inner: word
    }

    /// Commitment to the account vault
    record vault-commitment {
        inner: word
    }

    /// An index of the created note
    record note-idx {
        inner: felt
    }

    record note-type {
        inner: felt
    }

    record note-execution-hint {
        inner: felt
    }

}


/// The transaction script interface that is expected to be implemented by transaction scripts.
interface transaction-script {
    use core-types.{word};

    run: func(arg: word);
}

world base-world {
    export core-types;
    export transaction-script;
}