address_derivation.cpp

Go to the documentation of this file.

#include "barretenberg/vm2/simulation/gadgets/address_derivation.hpp"
 
#include <cassert>
 
#include "barretenberg/vm2/common/aztec_constants.hpp"
#include "barretenberg/vm2/common/field.hpp"
 
namespace bb::avm2::simulation {
 
void AddressDerivation::assert_derivation(const AztecAddress& address, const ContractInstance& instance)
{
    // Check if we've already derived this address
    if (cached_derivations.contains(address)) {
        // Already processed this address - cache hit, don't emit event
        return;
    }
 
    // First time seeing this address - do the actual derivation
    FF salted_initialization_hash =
        poseidon2.hash({ DOM_SEP__PARTIAL_ADDRESS, instance.salt, instance.initialization_hash, instance.deployer });
 
    FF partial_address =
        poseidon2.hash({ DOM_SEP__PARTIAL_ADDRESS, instance.original_contract_class_id, salted_initialization_hash });
 
    std::vector<FF> public_keys_hash_fields = instance.public_keys.to_fields();
    std::vector<FF> public_key_hash_vec{ DOM_SEP__PUBLIC_KEYS_HASH };
    for (size_t i = 0; i < public_keys_hash_fields.size(); i += 2) {
        public_key_hash_vec.push_back(public_keys_hash_fields[i]);
        public_key_hash_vec.push_back(public_keys_hash_fields[i + 1]);
        // is_infinity will be removed from address preimage, asumming false.
        public_key_hash_vec.push_back(FF::zero());
    }
    FF public_keys_hash = poseidon2.hash(public_key_hash_vec);
 
    FF preaddress = poseidon2.hash({ DOM_SEP__CONTRACT_ADDRESS_V1, public_keys_hash, partial_address });
 
    // Note: the below ecc calls assume points are on the curve. We know preaddress_public_key is (by definition),
    // but it may be possible that incoming_viewing_key is not.
    EmbeddedCurvePoint preaddress_public_key = ecc.scalar_mul(EmbeddedCurvePoint::one(), preaddress);
    EmbeddedCurvePoint address_point = ecc.add(preaddress_public_key, instance.public_keys.incoming_viewing_key);
 
    BB_ASSERT_EQ(address, address_point.x(), "Address derivation mismatch");
 
    // Cache this derivation so we don't repeat it
    cached_derivations.insert(address);
 
    events.emit({
        .address = address,
        .instance = instance,
        .salted_initialization_hash = salted_initialization_hash,
        .partial_address = partial_address,
        .public_keys_hash = public_keys_hash,
        .preaddress = preaddress,
        .preaddress_public_key = preaddress_public_key,
        .address_point = address_point,
    });
}
 
} // namespace bb::avm2::simulation