Skip to main content

gear_core/message/
init.rs

1// Copyright (C) Gear Technologies Inc.
2// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
3
4use crate::{
5    buffer::Payload,
6    ids::{ActorId, CodeId, MessageId, prelude::*},
7    message::{
8        Dispatch, DispatchKind, GasLimit, Message, Packet, Salt, StoredDispatch, StoredMessage,
9        Value,
10    },
11};
12
13/// Message for Init entry point.
14/// Used to initiate a newly created program.
15#[derive(Clone, Debug, PartialEq, Eq)]
16pub struct InitMessage {
17    /// Message id.
18    id: MessageId,
19    /// Message destination.
20    destination: ActorId,
21    /// Message payload.
22    payload: Payload,
23    /// Message optional gas limit.
24    gas_limit: Option<GasLimit>,
25    /// Message value.
26    value: Value,
27}
28
29impl InitMessage {
30    /// Create InitMessage from InitPacket.
31    pub fn from_packet(id: MessageId, packet: InitPacket) -> Self {
32        Self {
33            id,
34            destination: packet.program_id,
35            payload: packet.payload,
36            gas_limit: packet.gas_limit,
37            value: packet.value,
38        }
39    }
40
41    /// Convert InitMessage into Message.
42    pub fn into_message(self, source: ActorId) -> Message {
43        Message::new(
44            self.id,
45            source,
46            self.destination,
47            self.payload,
48            self.gas_limit,
49            self.value,
50            None,
51        )
52    }
53
54    /// Convert InitMessage into StoredMessage.
55    pub fn into_stored(self, source: ActorId) -> StoredMessage {
56        self.into_message(source).into_stored()
57    }
58
59    /// Convert InitMessage into Dispatch.
60    pub fn into_dispatch(self, source: ActorId) -> Dispatch {
61        Dispatch::new(DispatchKind::Init, self.into_message(source))
62    }
63
64    /// Convert InitMessage into StoredDispatch.
65    pub fn into_stored_dispatch(self, source: ActorId) -> StoredDispatch {
66        self.into_dispatch(source).into_stored()
67    }
68
69    /// Message id.
70    pub fn id(&self) -> MessageId {
71        self.id
72    }
73
74    /// Message destination.
75    pub fn destination(&self) -> ActorId {
76        self.destination
77    }
78
79    /// Message payload bytes.
80    pub fn payload_bytes(&self) -> &[u8] {
81        &self.payload
82    }
83
84    /// Message optional gas limit.
85    pub fn gas_limit(&self) -> Option<GasLimit> {
86        self.gas_limit
87    }
88
89    /// Message value.
90    pub fn value(&self) -> Value {
91        self.value
92    }
93}
94
95// TODO: #issue 3320
96/// Init message packet.
97///
98/// This structure is preparation for future init message sending. Has no message id.
99#[derive(Clone, Debug, PartialEq, Eq)]
100#[cfg_attr(any(feature = "mock", test), derive(Default))]
101pub struct InitPacket {
102    /// Newly created program id.
103    program_id: ActorId,
104    /// Code id.
105    code_id: CodeId,
106    /// Salt.
107    salt: Salt,
108    /// Message payload.
109    payload: Payload,
110    /// Message optional gas limit.
111    gas_limit: Option<GasLimit>,
112    /// Message value.
113    value: Value,
114}
115
116impl InitPacket {
117    /// Create new InitPacket via user.
118    pub fn new_from_user(
119        code_id: CodeId,
120        salt: Salt,
121        payload: Payload,
122        gas_limit: GasLimit,
123        value: Value,
124    ) -> Self {
125        Self {
126            program_id: ActorId::generate_from_user(code_id, &salt),
127            code_id,
128            salt,
129            payload,
130            gas_limit: Some(gas_limit),
131            value,
132        }
133    }
134
135    /// Create new InitPacket via program.
136    pub fn new_from_program(
137        code_id: CodeId,
138        salt: Salt,
139        payload: Payload,
140        message_id: MessageId,
141        gas_limit: Option<GasLimit>,
142        value: Value,
143    ) -> Self {
144        Self {
145            program_id: ActorId::generate_from_program(message_id, code_id, &salt),
146            code_id,
147            salt,
148            payload,
149            gas_limit,
150            value,
151        }
152    }
153
154    /// Packet destination (newly created program id).
155    pub fn destination(&self) -> ActorId {
156        self.program_id
157    }
158
159    /// Code id.
160    pub fn code_id(&self) -> CodeId {
161        self.code_id
162    }
163
164    /// Salt.
165    pub fn salt(&self) -> &[u8] {
166        &self.salt
167    }
168}
169
170impl Packet for InitPacket {
171    fn payload_bytes(&self) -> &[u8] {
172        &self.payload
173    }
174
175    fn payload_len(&self) -> u32 {
176        self.payload.len_u32()
177    }
178
179    fn gas_limit(&self) -> Option<GasLimit> {
180        self.gas_limit
181    }
182
183    fn value(&self) -> Value {
184        self.value
185    }
186
187    fn kind() -> DispatchKind {
188        DispatchKind::Init
189    }
190}