DNA ADDRESS != DNA entry address

ddd-mtl · April 21, 2020, 3:18am

I see that the address of the dna entry is different from the “official” DNA ADDRESS.
So using hdk::link_entries(&*hdk::DNA_ADDRESS, ...) doesn’t work since that’s not a valid base address for a link.
Instead I have to do a workaround of querying for the dna entry with hdk::query(EntryType::Dna) and use that address when linking.

If its a bug, can it be fixed so we can do hdk::link_entries(&*hdk::DNA_ADDRESS, ...) ?
Otherwise can we add a global for it like DNA_ENTRY_ADDRESS, so I don’t have to query the entry everytime I need this base address?

(I’m using v0.0.47-alpha1)

@lucksus @maackle @zippy

ddd-mtl · April 21, 2020, 6:38pm

It could be the same problem for agent address. I’ll check it out.

Edit: Actually not. Agent entry address is same as AGENT_ADDRESS

Connoropolous · April 22, 2020, 11:54am

what are you using to determine the “official” DNA ADDRESS? hc hash?

I’m guessing this is a bug

Connoropolous · April 22, 2020, 11:57am

In fact, it was a bug that wasn’t hard to find!
Look at this Damien!

github.com

holochain/holochain-rust/blob/9564458505299c668fbf7fb311eaad86a07c6551/crates/core/src/wasm_engine/api/init_globals.rs#L29


pub fn invoke_init_globals(runtime: &mut Runtime, _args: &RuntimeArgs) -> ZomeApiResult {
    let call_data = runtime.call_data()?;
    let dna = runtime
        .context()?
        .get_dna()
        .expect("No DNA found in invoke_init_globals");
    let dna_name = dna.name.clone();
    // Create the ZomeApiGlobals struct with some default values
    let mut globals = ZomeApiGlobals {
        dna_name,
        dna_address: Address::from(""),
        agent_id_str: JsonString::from(call_data.context.agent_id.clone()).to_string(),
        agent_address: call_data.context.agent_id.address(),
        agent_initial_hash: HashString::from(""),
        agent_latest_hash: HashString::from(""),
        public_token: Address::from(""),
        cap_request: runtime
            .zome_call_data()
            .map(|zome_call_data| Some(zome_call_data.call.cap))
            .unwrap_or_else(|_| None),
        properties: JsonString::from(dna.properties),

This variable ultimately ends up referenced as hdk::DNA_ADDRESS I think. So that seems to have always been wrong.

Connoropolous · April 22, 2020, 12:01pm

I just created a GH issue… thinking about even creating a PR since its like a one-liner.

Connoropolous · April 22, 2020, 12:08pm

Oops, gotta read on.

It should get updated here.

github.com

holochain/holochain-rust/blob/9564458505299c668fbf7fb311eaad86a07c6551/crates/core/src/wasm_engine/api/init_globals.rs#L44-L47

    
      
          // Update dna_address
          if let Some(dna) = state.nucleus().dna() {
              globals.dna_address = dna.address()
          }

Connoropolous · April 22, 2020, 1:15pm

I wanted to look into it, and ended up reproducing it to do that… so I am seeing what you are seeing, having written it up in a test, from a fresh hc-happ-create project folder.

github.com

Connoropolous/holochain-dna-bug-reproduce/blob/190abd383358bf6e436ead76d714cff738caeb38/dna_src/test/notes/index.js#L2-L11


scenario("compare dna address with dna entry address", async (s, t) => {
  const {alice} = await s.players({alice: conductorConfig}, true)
  const DNA_ADDRESS = await alice.call("notes", "notes", "dna_address", {})
  const QUERIED_DNA_ADDRESS = await alice.call("notes", "notes", "queried_dna_address", {})
  // passes
  // t.equal(alice.info('notes').dnaAddress, DNA_ADDRESS.Ok)
  
  // doesn't pass
  t.equal(QUERIED_DNA_ADDRESS.Ok, DNA_ADDRESS.Ok)
})

I’ll add this with steps to reproduce to the GH issue

Looking ever deeper into this (dang curiousity!)

Looks like in a lot of the places where the DNA address is returned, it is dealing in the thing stored as content INSIDE the Entry::Dna … so the raw DNA.

The get_dna function which is called in many places returns

github.com

holochain/holochain-rust/blob/9564458505299c668fbf7fb311eaad86a07c6551/crates/core/src/state.rs#L145


                    .to_string(),
            )
        })?;
    let json = (*cas.read().unwrap()).fetch(dna_entry_header.entry_address())?;
    let entry: Entry = json.map(|e| e.try_into()).ok_or_else(|| {
        HolochainError::ErrorGeneric(
            "No DNA entry found in storage while creating state from agent".to_string(),
        )
    })??;
    match entry {
        Entry::Dna(dna) => Ok(*dna),
        _ => Err(HolochainError::SerializationError(
            "Tried to get Dna from non-Dna Entry".into(),
        )),
    }
}


#[autotrace]
pub fn reduce(&self, action_wrapper: ActionWrapper) -> Self {
    let _span_guard = ht::push_span_with(|span| {
        span.child_("reduce-inner", |s| {

That returned dna struct is then used around the code to call dna.address()

This line makes it more obvious how that address will differ from the committed Entry::Dna(dna) entry, if we return its address using something like…

...
let dna_entry = Entry::Dna(dna);
let dna_address = dna_entry.address();

during initialization, the dna entry is committed to the chain as

github.com

holochain/holochain-rust/blob/53a61c1bdc6c7f6b9eb435855861d4c9704e4966/crates/core/src/nucleus/actions/initialize.rs#L88-L89


let dna_entry = Entry::Dna(Box::new(dna.clone()));
let dna_commit = commit_entry(dna_entry, None, &context_clone).await;

github.com

holochain/holochain-rust/blob/develop/crates/core_types/src/entry/mod.rs#L111


    fn eq(&self, other: &Entry) -> bool {
        self.address() == other.address()
    }
}


impl AddressableContent for Entry {
    fn address(&self) -> Address {
        match &self {
            Entry::AgentId(agent_id) => agent_id.address(),
            Entry::ChainHeader(chain_header) => chain_header.address(),
            _ => Address::encode_from_str(&String::from(self.content()), Hash::SHA2256),
        }
    }


    fn content(&self) -> Content {
        match &self {
            Entry::ChainHeader(chain_header) => chain_header.into(),
            _ => self.into(),
        }
    }