Struct WK

Constructors

Inner structs

Example

Consistency checks

import std.string: representation;
import agora.crypto.ECC;

enum Stride = 23;

static assert(WK.Keys[0] == WK.Keys.A);
static assert(WK.Keys[Stride - 1] == WK.Keys.Z);
static assert(WK.Keys[Stride] == WK.Keys.AA);
static assert(WK.Keys[Stride + (Stride * Stride) - 1] == WK.Keys.ZZ);
static assert(WK.Keys[Stride + (Stride * Stride)] == WK.Keys.AAA);
static assert(WK.Keys[1080] == WK.Keys.AZZ);

// Range interface
static assert(WK.Keys.byRange.length == 1080);

// Key from index
static assert(WK.Keys[WK.Keys.A.address] == WK.Keys.A);
static assert(WK.Keys[WK.Keys.Q.address] == WK.Keys.Q);
static assert(WK.Keys[WK.Keys.Z.address] == WK.Keys.Z);

/// Sign / Verify work
const sa = WK.Keys.A.secret.sign("WK.Keys.A".representation);
assert(WK.Keys.A.address.verify(sa, "WK.Keys.A".representation));
const sq = WK.Keys.Q.secret.sign("WK.Keys.Q".representation);
assert(WK.Keys.Q.address.verify(sq, "WK.Keys.Q".representation));
const sz = WK.Keys.Z.secret.sign("WK.Keys.Z".representation);
assert(WK.Keys.Z.address.verify(sz, "WK.Keys.Z".representation));

// Test for valid ECC Scalar and Point for several keys
static void assertValidECC (KeyPair[] keys...)
{
    foreach (keypair; keys)
    {
        assert(keypair.address.isValid(),
               format!"WK keypair (%s, %s) should have valid Point for PublicKey"
               (keypair.address, keypair.secret.toString(PrintMode.Clear)));
        assert(keypair.secret.isValid(),
               format!"WK keypair (%s, %s) should have valid Scalar for Secretkey"
               (keypair.address, keypair.secret.toString(PrintMode.Clear)));
        assert(keypair.secret.toPoint() == keypair.address,
               format!"WK secret %s should have Point as v.G: %s"
               (keypair.secret.toString(PrintMode.Clear), keypair.secret.toPoint()));
    }
}

assertValidECC(WK.Keys.Genesis,
               WK.Keys.CommonsBudget,
               WK.Keys.NODE2,
               WK.Keys.NODE3,
               WK.Keys.NODE4,
               WK.Keys.NODE5,
               WK.Keys.NODE6,
               WK.Keys.NODE7,
               WK.Keys.A,
               WK.Keys.Q,
               WK.Keys.ZZ);

// Also with the Schnorr functions
{
    auto pa = Pair.fromScalar(WK.Keys.A.secret);
    assert(pa.V == WK.Keys.A.address);
    const ssa = sign(pa, "WK.Keys.A".representation);
    assert(verify(pa.V, ssa, "WK.Keys.A".representation));
    assert(!verify(pa.V, ssa, "WK.Keys.a".representation));

    auto pq = Pair.fromScalar(WK.Keys.Q.secret);
    assert(pq.V == WK.Keys.Q.address);
    const ssq = sign(pq, "WK.Keys.Q".representation);
    assert(verify(pq.V, ssq, "WK.Keys.Q".representation));
    assert(!verify(pq.V, ssq, "WK.Keys.q".representation));

    auto pz = Pair.fromScalar(WK.Keys.Z.secret);
    assert(pz.V == WK.Keys.Z.address);
    const ssz = sign(pz, "WK.Keys.Z".representation);
    assert(verify(pz.V, ssz, "WK.Keys.Z".representation));
    assert(!verify(pz.V, ssz, "WK.Keys.z".representation));
}

/// Test that Genesis is found
{
    auto genesisKP = WK.Keys.Genesis;
    assert(WK.Keys[genesisKP.address] == genesisKP);
    // Sanity check with `agora.consensus.Genesis`
    GenesisBlock.payments
        .each!(tx => tx.outputs
            .each!(output => assert(WK.Keys.Genesis.address == output.address)));
}