hypercore 0.16.0

Secure, distributed, append-only log
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

const Hypercore = require('hypercore');

// Static test key pair obtained with:
//
//   const crypto = require('hypercore-crypto');
//   const keyPair = crypto.keyPair();
//   console.log("public key", keyPair.publicKey.toString('hex').match(/../g).join(' '));
//   console.log("secret key", keyPair.secretKey.toString('hex').match(/../g).join(' '));
const testKeyPair = {
    publicKey: Buffer.from([
        0x97, 0x60, 0x6c, 0xaa, 0xd2, 0xb0, 0x8c, 0x1d, 0x5f, 0xe1, 0x64, 0x2e, 0xee, 0xa5, 0x62, 0xcb,
        0x91, 0xd6, 0x55, 0xe2, 0x00, 0xc8, 0xd4, 0x3a, 0x32, 0x09, 0x1d, 0x06, 0x4a, 0x33, 0x1e, 0xe3]),
    secretKey: Buffer.from([
        0x27, 0xe6, 0x74, 0x25, 0xc1, 0xff, 0xd1, 0xd9, 0xee, 0x62, 0x5c, 0x96, 0x2b, 0x57, 0x13, 0xc3,
        0x51, 0x0b, 0x71, 0x14, 0x15, 0xf3, 0x31, 0xf6, 0xfa, 0x9e, 0xf2, 0xbf, 0x23, 0x5f, 0x2f, 0xfe,
        0x97, 0x60, 0x6c, 0xaa, 0xd2, 0xb0, 0x8c, 0x1d, 0x5f, 0xe1, 0x64, 0x2e, 0xee, 0xa5, 0x62, 0xcb,
        0x91, 0xd6, 0x55, 0xe2, 0x00, 0xc8, 0xd4, 0x3a, 0x32, 0x09, 0x1d, 0x06, 0x4a, 0x33, 0x1e, 0xe3]),
}

if (process.argv.length !== 4) {
    console.error("Usage: node interop.js [test step] [test set]")
    process.exit(1);
}

if (process.argv[2] === '1') {
    step1Create(process.argv[3]).then(result => {
        console.log("step1 ready", result);
    });
} else if (process.argv[2] === '2'){
    step2AppendHelloWorld(process.argv[3]).then(result => {
        console.log("step2 ready", result);
    });
} else if (process.argv[2] === '3'){
    step3ReadAndAppendUnflushed(process.argv[3]).then(result => {
        console.log("step3 ready", result);
    });
} else if (process.argv[2] === '4'){
    step4AppendWithFlush(process.argv[3]).then(result => {
        console.log("step4 ready", result);
    });
} else if (process.argv[2] === '5'){
    step5ClearSome(process.argv[3]).then(result => {
        console.log("step5 ready", result);
    });
} else {
    console.error(`Invalid test step {}`, process.argv[2]);
    process.exit(2);
}

async function step1Create(testSet) {
    const core = new Hypercore(`work/${testSet}`, testKeyPair.publicKey, {keyPair: testKeyPair});
    await core.close();
};

async function step2AppendHelloWorld(testSet) {
    const core = new Hypercore(`work/${testSet}`, testKeyPair.publicKey, {keyPair: testKeyPair});
    const result = await core.append([Buffer.from('Hello'), Buffer.from('World')]);
    assert(result.length, 2);
    assert(result.byteLength, 10);
    await core.close();
};

async function step3ReadAndAppendUnflushed(testSet) {
    const core = new Hypercore(`work/${testSet}`, testKeyPair.publicKey, {keyPair: testKeyPair});
    const hello = (await core.get(0)).toString();
    const world = (await core.get(1)).toString();
    assert(hello, "Hello");
    assert(world, "World");
    let result = await core.append(Buffer.from('first'));
    assert(result.length, 3);
    assert(result.byteLength, 15);
    result = await core.append([Buffer.from('second'), Buffer.from('third')]);
    assert(result.length, 5);
    assert(result.byteLength, 26);
    const multiBlock = Buffer.alloc(4096*3, 'a');
    result = await core.append(multiBlock);
    assert(result.length, 6);
    assert(result.byteLength, 12314);
    result = await core.append([]);
    assert(result.length, 6);
    assert(result.byteLength, 12314);
    const first = (await core.get(2)).toString();
    assert(first, "first");
    const second = (await core.get(3)).toString();
    assert(second, "second");
    const third = (await core.get(4)).toString();
    assert(third, "third");
    const multiBlockRead = await core.get(5);
    if (!multiBlockRead.equals(multiBlock)) {
        throw new Error(`Read buffers don't equal, ${multiBlockRead} but expected ${multiBlock}`);
    }
    await core.close();
};

async function step4AppendWithFlush(testSet) {
    const core = new Hypercore(`work/${testSet}`, testKeyPair.publicKey, {keyPair: testKeyPair});
    for (let i=0; i<5; i++) {
        result = await core.append(Buffer.from([i]));
        assert(result.length, 6+i+1);
        assert(result.byteLength, 12314+i+1);
    }
}

async function step5ClearSome(testSet) {
    const core = new Hypercore(`work/${testSet}`, testKeyPair.publicKey, {keyPair: testKeyPair});
    await core.clear(5);
    await core.clear(7, 9);
    let info = await core.info();
    assert(info.length, 11);
    assert(info.byteLength, 12319);
    assert(info.contiguousLength, 5);
    assert(info.padding, 0);

    let missing = await core.get(5, { wait: false });
    assert(missing, null);
    missing = await core.get(7, { wait: false });
    assert(missing, null);
    missing = await core.get(8, { wait: false });
    assert(missing, null);
    const third = (await core.get(4)).toString();
    assert(third, "third");
}

function assert(real, expected) {
    if (real != expected)  {
        throw new Error(`Got ${real} but expected ${expected}`);
    }
}