solang 0.3.5

Solang Solidity Compiler
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

// SPDX-License-Identifier: Apache-2.0

use crate::abi::anchor::event_discriminator;
use crate::codegen::cfg::{ControlFlowGraph, Instr};
use crate::codegen::encoding::abi_encode;
use crate::codegen::expression::expression;
use crate::codegen::interface::EventEmitter;
use crate::codegen::interface::TargetCodegen;
use crate::codegen::vartable::Vartable;
use crate::codegen::{Expression, Options};
use crate::sema::ast;
use crate::sema::ast::{Function, Namespace, Type};
use solang_parser::pt::Loc;

/// This struct implements the trait 'EventEmitter' to handle the emission of events for Solana.
pub(crate) struct SolanaEventEmitter<'a> {
    pub(crate) loc: Loc,
    /// Arguments passed to the event
    pub(crate) args: &'a [ast::Expression],
    pub(crate) ns: &'a Namespace,
    pub(crate) event_no: usize,
}

impl EventEmitter for SolanaEventEmitter<'_> {
    fn selector(&self, _: usize) -> Vec<u8> {
        event_discriminator(&self.ns.events[self.event_no].id.name)
    }

    fn emit(
        &self,
        contract_no: usize,
        func: &Function,
        cfg: &mut ControlFlowGraph,
        vartab: &mut Vartable,
        opt: &Options,
        target: &dyn TargetCodegen,
    ) {
        let discriminator = Expression::BytesLiteral {
            loc: Loc::Codegen,
            ty: Type::Bytes(8),
            value: self.selector(contract_no),
        };

        let mut codegen_args = self
            .args
            .iter()
            .map(|e| {
                expression(
                    e,
                    cfg,
                    contract_no,
                    Some(func),
                    self.ns,
                    vartab,
                    opt,
                    target,
                )
            })
            .collect::<Vec<Expression>>();

        let mut to_be_encoded: Vec<Expression> = vec![discriminator];
        to_be_encoded.append(&mut codegen_args);
        let data = abi_encode(&self.loc, to_be_encoded, self.ns, vartab, cfg, false).0;

        cfg.add(
            vartab,
            Instr::EmitEvent {
                event_no: self.event_no,
                data,
                topics: vec![],
            },
        );
    }
}