holochain_client 0.8.0-dev.0

A Rust client for the Holochain Conductor API
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

use bytes::Bytes;
use holochain::prelude::DnaModifiersOpt;
use holochain_types::app::{
    AppManifest, AppManifestV1, AppRoleDnaManifest, AppRoleManifest, CellProvisioning,
};
use holochain_types::dna::{
    CoordinatorManifest, DnaBundle, DnaManifest, DnaManifestV1, IntegrityManifest,
    ValidatedDnaManifest, ZomeDependency, ZomeManifest,
};
use holochain_types::prelude::AppBundle;
use holochain_wasm_test_utils::{TestWasm, TestWasmPair};
use mr_bundle::ResourceBytes;
use std::path::PathBuf;
use std::sync::OnceLock;

pub fn get_fixture_app_bundle() -> Bytes {
    static TEST_APP_BUNDLE: OnceLock<Bytes> = OnceLock::new();

    TEST_APP_BUNDLE.get_or_init(make_fixture_app_bundle).clone()
}

fn make_fixture_app_bundle() -> Bytes {
    let dna_manifest = ValidatedDnaManifest::try_from(DnaManifest::V1(DnaManifestV1 {
        name: "test-dna".to_string(),
        coordinator: CoordinatorManifest {
            zomes: vec![ZomeManifest {
                name: "foo".into(),
                hash: None,
                dependencies: Some(vec![ZomeDependency {
                    name: "foo_integrity".into(),
                }]),
                path: "test_wasm_client.wasm".to_string(),
            }],
        },
        integrity: IntegrityManifest {
            network_seed: None,
            properties: None,
            zomes: vec![ZomeManifest {
                name: "foo_integrity".into(),
                hash: None,
                dependencies: None,
                path: "integrity_test_wasm_client.wasm".to_string(),
            }],
        },
        #[cfg(feature = "unstable-migration")]
        lineage: vec![],
    }))
    .unwrap();

    let (integrity, coordinator) = get_test_wasm_pair(TestWasm::Client);
    let dna_bundle = DnaBundle::new(
        dna_manifest,
        vec![
            ("integrity_test_wasm_client.wasm".to_string(), integrity),
            ("test_wasm_client.wasm".to_string(), coordinator),
        ],
    )
    .unwrap();

    let app_manifest = AppManifest::V1(AppManifestV1 {
        name: "fixture".to_string(),
        description: None,
        allow_deferred_memproofs: false,
        roles: vec![AppRoleManifest {
            name: "foo".to_string(),
            provisioning: Some(CellProvisioning::Create { deferred: false }),
            dna: AppRoleDnaManifest {
                path: Some("test.dna".to_string()),
                modifiers: DnaModifiersOpt::none(),
                installed_hash: None,
                clone_limit: 10,
            },
        }],
    });

    let app = AppBundle::new(app_manifest, vec![("test.dna".to_string(), dna_bundle)]).unwrap();

    app.pack().unwrap()
}

fn get_test_wasm_pair(wasm: TestWasm) -> (ResourceBytes, ResourceBytes) {
    let base = PathBuf::from("../test_utils/wasm/wasm_workspace/target/");
    let TestWasmPair {
        integrity: integrity_path,
        coordinator: coordinator_path,
    } = TestWasmPair::<PathBuf>::from(wasm);

    let integrity = std::fs::read(base.join(integrity_path)).unwrap();
    let coordinator = std::fs::read(base.join(coordinator_path)).unwrap();

    (integrity.into(), coordinator.into())
}