@typeberry/lib 0.1.3-462ca77 → 0.1.3-62eb49b

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/index.cjs +613 -1336
  2. package/index.d.ts +501 -598
  3. package/index.js +612 -1335
  4. package/package.json +1 -1
package/index.cjs CHANGED
@@ -38,8 +38,9 @@ function parseCurrentVersion(env) {
38
38
  }
39
39
  }
40
40
  function parseCurrentSuite(env) {
41
- if (env === undefined)
41
+ if (env === undefined) {
42
42
  return undefined;
43
+ }
43
44
  switch (env) {
44
45
  case TestSuite.W3F_DAVXY:
45
46
  case TestSuite.JAMDUNA:
@@ -459,10 +460,12 @@ function deepEqual(actual, expected, { context = [], errorsCollector, ignore = [
459
460
  .sort((a, b) => {
460
461
  const aKey = `${a.key}`;
461
462
  const bKey = `${b.key}`;
462
- if (aKey < bKey)
463
+ if (aKey < bKey) {
463
464
  return -1;
464
- if (bKey < aKey)
465
+ }
466
+ if (bKey < aKey) {
465
467
  return 1;
468
+ }
466
469
  return 0;
467
470
  });
468
471
  };
@@ -3654,823 +3657,75 @@ var ed25519 = /*#__PURE__*/Object.freeze({
3654
3657
  verifyBatch: verifyBatch
3655
3658
  });
3656
3659
 
3660
+ const SEED_SIZE = 32;
3661
+ const ED25519_SECRET_KEY = Bytes.blobFromString("jam_val_key_ed25519");
3662
+ const BANDERSNATCH_SECRET_KEY = Bytes.blobFromString("jam_val_key_bandersnatch");
3657
3663
  /**
3658
- * Size of the output of the hash functions.
3659
- *
3660
- * https://graypaper.fluffylabs.dev/#/579bd12/073101073c01
3664
+ * JIP-5: Secret key derivation
3661
3665
  *
3662
- */
3663
- const HASH_SIZE = 32;
3664
- /** A hash without last byte (useful for trie representation). */
3665
- const TRUNCATED_HASH_SIZE = 31;
3666
- const ZERO_HASH = Bytes.zero(HASH_SIZE);
3666
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md */
3667
3667
  /**
3668
- * Container for some object with a hash that is related to this object.
3669
- *
3670
- * After calculating the hash these two should be passed together to avoid
3671
- * unnecessary re-hashing of the data.
3668
+ * Deriving a 32-byte seed from a 32-bit unsigned integer
3669
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#trivial-seeds
3672
3670
  */
3673
- class WithHash extends WithDebug {
3674
- hash;
3675
- data;
3676
- constructor(hash, data) {
3677
- super();
3678
- this.hash = hash;
3679
- this.data = data;
3680
- }
3671
+ function trivialSeed(s) {
3672
+ const s_le = u32AsLeBytes(s);
3673
+ return Bytes.fromBlob(BytesBlob.blobFromParts([s_le, s_le, s_le, s_le, s_le, s_le, s_le, s_le]).raw, SEED_SIZE).asOpaque();
3681
3674
  }
3682
3675
  /**
3683
- * Extension of [`WithHash`] additionally containing an encoded version of the object.
3676
+ * Derives a Ed25519 secret key from a seed.
3677
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
3684
3678
  */
3685
- class WithHashAndBytes extends WithHash {
3686
- encoded;
3687
- constructor(hash, data, encoded) {
3688
- super(hash, data);
3689
- this.encoded = encoded;
3690
- }
3691
- }
3692
-
3693
- /** The simplest allocator returning just a fresh copy of bytes each time. */
3694
- class SimpleAllocator {
3695
- emptyHash() {
3696
- return Bytes.zero(HASH_SIZE);
3697
- }
3698
- }
3699
- /** An allocator that works by allocating larger (continuous) pages of memory. */
3700
- class PageAllocator {
3701
- hashesPerPage;
3702
- page = safeAllocUint8Array(0);
3703
- currentHash = 0;
3704
- // TODO [ToDr] Benchmark the performance!
3705
- constructor(hashesPerPage) {
3706
- this.hashesPerPage = hashesPerPage;
3707
- check `${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
3708
- this.resetPage();
3709
- }
3710
- resetPage() {
3711
- const pageSizeBytes = this.hashesPerPage * HASH_SIZE;
3712
- this.currentHash = 0;
3713
- this.page = safeAllocUint8Array(pageSizeBytes);
3714
- }
3715
- emptyHash() {
3716
- const startIdx = this.currentHash * HASH_SIZE;
3717
- const endIdx = startIdx + HASH_SIZE;
3718
- this.currentHash += 1;
3719
- if (this.currentHash >= this.hashesPerPage) {
3720
- this.resetPage();
3721
- }
3722
- return Bytes.fromBlob(this.page.subarray(startIdx, endIdx), HASH_SIZE);
3723
- }
3724
- }
3725
- const defaultAllocator = new SimpleAllocator();
3726
-
3727
- function getDefaultExportFromCjs (x) {
3728
- return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
3729
- }
3730
-
3731
- var blake2b$3 = {exports: {}};
3732
-
3733
- var nanoassert;
3734
- var hasRequiredNanoassert;
3735
-
3736
- function requireNanoassert () {
3737
- if (hasRequiredNanoassert) return nanoassert;
3738
- hasRequiredNanoassert = 1;
3739
- nanoassert = assert;
3740
-
3741
- class AssertionError extends Error {}
3742
- AssertionError.prototype.name = 'AssertionError';
3743
-
3744
- /**
3745
- * Minimal assert function
3746
- * @param {any} t Value to check if falsy
3747
- * @param {string=} m Optional assertion error message
3748
- * @throws {AssertionError}
3749
- */
3750
- function assert (t, m) {
3751
- if (!t) {
3752
- var err = new AssertionError(m);
3753
- if (Error.captureStackTrace) Error.captureStackTrace(err, assert);
3754
- throw err
3755
- }
3756
- }
3757
- return nanoassert;
3758
- }
3759
-
3760
- var blake2bWasm = {exports: {}};
3761
-
3762
- var b4a;
3763
- var hasRequiredB4a;
3764
-
3765
- function requireB4a () {
3766
- if (hasRequiredB4a) return b4a;
3767
- hasRequiredB4a = 1;
3768
- function isBuffer (value) {
3769
- return Buffer.isBuffer(value) || value instanceof Uint8Array
3770
- }
3771
-
3772
- function isEncoding (encoding) {
3773
- return Buffer.isEncoding(encoding)
3774
- }
3775
-
3776
- function alloc (size, fill, encoding) {
3777
- return Buffer.alloc(size, fill, encoding)
3778
- }
3779
-
3780
- function allocUnsafe (size) {
3781
- return Buffer.allocUnsafe(size)
3782
- }
3783
-
3784
- function allocUnsafeSlow (size) {
3785
- return Buffer.allocUnsafeSlow(size)
3786
- }
3787
-
3788
- function byteLength (string, encoding) {
3789
- return Buffer.byteLength(string, encoding)
3790
- }
3791
-
3792
- function compare (a, b) {
3793
- return Buffer.compare(a, b)
3794
- }
3795
-
3796
- function concat (buffers, totalLength) {
3797
- return Buffer.concat(buffers, totalLength)
3798
- }
3799
-
3800
- function copy (source, target, targetStart, start, end) {
3801
- return toBuffer(source).copy(target, targetStart, start, end)
3802
- }
3803
-
3804
- function equals (a, b) {
3805
- return toBuffer(a).equals(b)
3806
- }
3807
-
3808
- function fill (buffer, value, offset, end, encoding) {
3809
- return toBuffer(buffer).fill(value, offset, end, encoding)
3810
- }
3811
-
3812
- function from (value, encodingOrOffset, length) {
3813
- return Buffer.from(value, encodingOrOffset, length)
3814
- }
3815
-
3816
- function includes (buffer, value, byteOffset, encoding) {
3817
- return toBuffer(buffer).includes(value, byteOffset, encoding)
3818
- }
3819
-
3820
- function indexOf (buffer, value, byfeOffset, encoding) {
3821
- return toBuffer(buffer).indexOf(value, byfeOffset, encoding)
3822
- }
3823
-
3824
- function lastIndexOf (buffer, value, byteOffset, encoding) {
3825
- return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding)
3826
- }
3827
-
3828
- function swap16 (buffer) {
3829
- return toBuffer(buffer).swap16()
3830
- }
3831
-
3832
- function swap32 (buffer) {
3833
- return toBuffer(buffer).swap32()
3834
- }
3835
-
3836
- function swap64 (buffer) {
3837
- return toBuffer(buffer).swap64()
3838
- }
3839
-
3840
- function toBuffer (buffer) {
3841
- if (Buffer.isBuffer(buffer)) return buffer
3842
- return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)
3843
- }
3844
-
3845
- function toString (buffer, encoding, start, end) {
3846
- return toBuffer(buffer).toString(encoding, start, end)
3847
- }
3848
-
3849
- function write (buffer, string, offset, length, encoding) {
3850
- return toBuffer(buffer).write(string, offset, length, encoding)
3851
- }
3852
-
3853
- function writeDoubleLE (buffer, value, offset) {
3854
- return toBuffer(buffer).writeDoubleLE(value, offset)
3855
- }
3856
-
3857
- function writeFloatLE (buffer, value, offset) {
3858
- return toBuffer(buffer).writeFloatLE(value, offset)
3859
- }
3860
-
3861
- function writeUInt32LE (buffer, value, offset) {
3862
- return toBuffer(buffer).writeUInt32LE(value, offset)
3863
- }
3864
-
3865
- function writeInt32LE (buffer, value, offset) {
3866
- return toBuffer(buffer).writeInt32LE(value, offset)
3867
- }
3868
-
3869
- function readDoubleLE (buffer, offset) {
3870
- return toBuffer(buffer).readDoubleLE(offset)
3871
- }
3872
-
3873
- function readFloatLE (buffer, offset) {
3874
- return toBuffer(buffer).readFloatLE(offset)
3875
- }
3876
-
3877
- function readUInt32LE (buffer, offset) {
3878
- return toBuffer(buffer).readUInt32LE(offset)
3879
- }
3880
-
3881
- function readInt32LE (buffer, offset) {
3882
- return toBuffer(buffer).readInt32LE(offset)
3883
- }
3884
-
3885
- b4a = {
3886
- isBuffer,
3887
- isEncoding,
3888
- alloc,
3889
- allocUnsafe,
3890
- allocUnsafeSlow,
3891
- byteLength,
3892
- compare,
3893
- concat,
3894
- copy,
3895
- equals,
3896
- fill,
3897
- from,
3898
- includes,
3899
- indexOf,
3900
- lastIndexOf,
3901
- swap16,
3902
- swap32,
3903
- swap64,
3904
- toBuffer,
3905
- toString,
3906
- write,
3907
- writeDoubleLE,
3908
- writeFloatLE,
3909
- writeUInt32LE,
3910
- writeInt32LE,
3911
- readDoubleLE,
3912
- readFloatLE,
3913
- readUInt32LE,
3914
- readInt32LE
3915
- };
3916
- return b4a;
3917
- }
3918
-
3919
- var blake2b$2;
3920
- var hasRequiredBlake2b$1;
3921
-
3922
- function requireBlake2b$1 () {
3923
- if (hasRequiredBlake2b$1) return blake2b$2;
3924
- hasRequiredBlake2b$1 = 1;
3925
- var __commonJS = (cb, mod) => function __require() {
3926
- return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
3927
- };
3928
- var __toBinary = /* @__PURE__ */ (() => {
3929
- var table = new Uint8Array(128);
3930
- for (var i = 0; i < 64; i++)
3931
- table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;
3932
- return (base64) => {
3933
- var n = base64.length, bytes2 = new Uint8Array((n - (base64[n - 1] == "=") - (base64[n - 2] == "=")) * 3 / 4 | 0);
3934
- for (var i2 = 0, j = 0; i2 < n; ) {
3935
- var c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)];
3936
- var c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)];
3937
- bytes2[j++] = c0 << 2 | c1 >> 4;
3938
- bytes2[j++] = c1 << 4 | c2 >> 2;
3939
- bytes2[j++] = c2 << 6 | c3;
3940
- }
3941
- return bytes2;
3942
- };
3943
- })();
3944
-
3945
- // wasm-binary:./blake2b.wat
3946
- var require_blake2b = __commonJS({
3947
- "wasm-binary:./blake2b.wat"(exports2, module2) {
3948
- module2.exports = __toBinary("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");
3949
- }
3950
- });
3951
-
3952
- // wasm-module:./blake2b.wat
3953
- var bytes = require_blake2b();
3954
- var compiled = WebAssembly.compile(bytes);
3955
- blake2b$2 = async (imports) => {
3956
- const instance = await WebAssembly.instantiate(await compiled, imports);
3957
- return instance.exports;
3958
- };
3959
- return blake2b$2;
3960
- }
3961
-
3962
- var hasRequiredBlake2bWasm;
3963
-
3964
- function requireBlake2bWasm () {
3965
- if (hasRequiredBlake2bWasm) return blake2bWasm.exports;
3966
- hasRequiredBlake2bWasm = 1;
3967
- var assert = /*@__PURE__*/ requireNanoassert();
3968
- var b4a = /*@__PURE__*/ requireB4a();
3969
-
3970
- var wasm = null;
3971
- var wasmPromise = typeof WebAssembly !== "undefined" && /*@__PURE__*/ requireBlake2b$1()().then(mod => {
3972
- wasm = mod;
3973
- });
3974
-
3975
- var head = 64;
3976
- var freeList = [];
3977
-
3978
- blake2bWasm.exports = Blake2b;
3979
- var BYTES_MIN = blake2bWasm.exports.BYTES_MIN = 16;
3980
- var BYTES_MAX = blake2bWasm.exports.BYTES_MAX = 64;
3981
- blake2bWasm.exports.BYTES = 32;
3982
- var KEYBYTES_MIN = blake2bWasm.exports.KEYBYTES_MIN = 16;
3983
- var KEYBYTES_MAX = blake2bWasm.exports.KEYBYTES_MAX = 64;
3984
- blake2bWasm.exports.KEYBYTES = 32;
3985
- var SALTBYTES = blake2bWasm.exports.SALTBYTES = 16;
3986
- var PERSONALBYTES = blake2bWasm.exports.PERSONALBYTES = 16;
3987
-
3988
- function Blake2b (digestLength, key, salt, personal, noAssert) {
3989
- if (!(this instanceof Blake2b)) return new Blake2b(digestLength, key, salt, personal, noAssert)
3990
- if (!wasm) throw new Error('WASM not loaded. Wait for Blake2b.ready(cb)')
3991
- if (!digestLength) digestLength = 32;
3992
-
3993
- if (noAssert !== true) {
3994
- assert(digestLength >= BYTES_MIN, 'digestLength must be at least ' + BYTES_MIN + ', was given ' + digestLength);
3995
- assert(digestLength <= BYTES_MAX, 'digestLength must be at most ' + BYTES_MAX + ', was given ' + digestLength);
3996
- if (key != null) {
3997
- assert(key instanceof Uint8Array, 'key must be Uint8Array or Buffer');
3998
- assert(key.length >= KEYBYTES_MIN, 'key must be at least ' + KEYBYTES_MIN + ', was given ' + key.length);
3999
- assert(key.length <= KEYBYTES_MAX, 'key must be at least ' + KEYBYTES_MAX + ', was given ' + key.length);
4000
- }
4001
- if (salt != null) {
4002
- assert(salt instanceof Uint8Array, 'salt must be Uint8Array or Buffer');
4003
- assert(salt.length === SALTBYTES, 'salt must be exactly ' + SALTBYTES + ', was given ' + salt.length);
4004
- }
4005
- if (personal != null) {
4006
- assert(personal instanceof Uint8Array, 'personal must be Uint8Array or Buffer');
4007
- assert(personal.length === PERSONALBYTES, 'personal must be exactly ' + PERSONALBYTES + ', was given ' + personal.length);
4008
- }
4009
- }
4010
-
4011
- if (!freeList.length) {
4012
- freeList.push(head);
4013
- head += 216;
4014
- }
4015
-
4016
- this.digestLength = digestLength;
4017
- this.finalized = false;
4018
- this.pointer = freeList.pop();
4019
- this._memory = new Uint8Array(wasm.memory.buffer);
4020
-
4021
- this._memory.fill(0, 0, 64);
4022
- this._memory[0] = this.digestLength;
4023
- this._memory[1] = key ? key.length : 0;
4024
- this._memory[2] = 1; // fanout
4025
- this._memory[3] = 1; // depth
4026
-
4027
- if (salt) this._memory.set(salt, 32);
4028
- if (personal) this._memory.set(personal, 48);
4029
-
4030
- if (this.pointer + 216 > this._memory.length) this._realloc(this.pointer + 216); // we need 216 bytes for the state
4031
- wasm.blake2b_init(this.pointer, this.digestLength);
4032
-
4033
- if (key) {
4034
- this.update(key);
4035
- this._memory.fill(0, head, head + key.length); // whiteout key
4036
- this._memory[this.pointer + 200] = 128;
4037
- }
4038
- }
4039
-
4040
- Blake2b.prototype._realloc = function (size) {
4041
- wasm.memory.grow(Math.max(0, Math.ceil(Math.abs(size - this._memory.length) / 65536)));
4042
- this._memory = new Uint8Array(wasm.memory.buffer);
4043
- };
4044
-
4045
- Blake2b.prototype.update = function (input) {
4046
- assert(this.finalized === false, 'Hash instance finalized');
4047
- assert(input instanceof Uint8Array, 'input must be Uint8Array or Buffer');
4048
-
4049
- if (head + input.length > this._memory.length) this._realloc(head + input.length);
4050
- this._memory.set(input, head);
4051
- wasm.blake2b_update(this.pointer, head, head + input.length);
4052
- return this
4053
- };
4054
-
4055
- Blake2b.prototype.digest = function (enc) {
4056
- assert(this.finalized === false, 'Hash instance finalized');
4057
- this.finalized = true;
4058
-
4059
- freeList.push(this.pointer);
4060
- wasm.blake2b_final(this.pointer);
4061
-
4062
- if (!enc || enc === 'binary') {
4063
- return this._memory.slice(this.pointer + 128, this.pointer + 128 + this.digestLength)
4064
- }
4065
-
4066
- if (typeof enc === 'string') {
4067
- return b4a.toString(this._memory, enc, this.pointer + 128, this.pointer + 128 + this.digestLength)
4068
- }
4069
-
4070
- assert(enc instanceof Uint8Array && enc.length >= this.digestLength, 'input must be Uint8Array or Buffer');
4071
- for (var i = 0; i < this.digestLength; i++) {
4072
- enc[i] = this._memory[this.pointer + 128 + i];
4073
- }
4074
-
4075
- return enc
4076
- };
4077
-
4078
- // libsodium compat
4079
- Blake2b.prototype.final = Blake2b.prototype.digest;
4080
-
4081
- Blake2b.WASM = wasm;
4082
- Blake2b.SUPPORTED = typeof WebAssembly !== 'undefined';
4083
-
4084
- Blake2b.ready = function (cb) {
4085
- if (!cb) cb = noop;
4086
- if (!wasmPromise) return cb(new Error('WebAssembly not supported'))
4087
- return wasmPromise.then(() => cb(), cb)
4088
- };
4089
-
4090
- Blake2b.prototype.ready = Blake2b.ready;
4091
-
4092
- Blake2b.prototype.getPartialHash = function () {
4093
- return this._memory.slice(this.pointer, this.pointer + 216);
4094
- };
4095
-
4096
- Blake2b.prototype.setPartialHash = function (ph) {
4097
- this._memory.set(ph, this.pointer);
4098
- };
4099
-
4100
- function noop () {}
4101
- return blake2bWasm.exports;
4102
- }
4103
-
4104
- var hasRequiredBlake2b;
4105
-
4106
- function requireBlake2b () {
4107
- if (hasRequiredBlake2b) return blake2b$3.exports;
4108
- hasRequiredBlake2b = 1;
4109
- var assert = /*@__PURE__*/ requireNanoassert();
4110
- var b2wasm = /*@__PURE__*/ requireBlake2bWasm();
4111
-
4112
- // 64-bit unsigned addition
4113
- // Sets v[a,a+1] += v[b,b+1]
4114
- // v should be a Uint32Array
4115
- function ADD64AA (v, a, b) {
4116
- var o0 = v[a] + v[b];
4117
- var o1 = v[a + 1] + v[b + 1];
4118
- if (o0 >= 0x100000000) {
4119
- o1++;
4120
- }
4121
- v[a] = o0;
4122
- v[a + 1] = o1;
4123
- }
4124
-
4125
- // 64-bit unsigned addition
4126
- // Sets v[a,a+1] += b
4127
- // b0 is the low 32 bits of b, b1 represents the high 32 bits
4128
- function ADD64AC (v, a, b0, b1) {
4129
- var o0 = v[a] + b0;
4130
- if (b0 < 0) {
4131
- o0 += 0x100000000;
4132
- }
4133
- var o1 = v[a + 1] + b1;
4134
- if (o0 >= 0x100000000) {
4135
- o1++;
4136
- }
4137
- v[a] = o0;
4138
- v[a + 1] = o1;
4139
- }
4140
-
4141
- // Little-endian byte access
4142
- function B2B_GET32 (arr, i) {
4143
- return (arr[i] ^
4144
- (arr[i + 1] << 8) ^
4145
- (arr[i + 2] << 16) ^
4146
- (arr[i + 3] << 24))
4147
- }
4148
-
4149
- // G Mixing function
4150
- // The ROTRs are inlined for speed
4151
- function B2B_G (a, b, c, d, ix, iy) {
4152
- var x0 = m[ix];
4153
- var x1 = m[ix + 1];
4154
- var y0 = m[iy];
4155
- var y1 = m[iy + 1];
4156
-
4157
- ADD64AA(v, a, b); // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
4158
- ADD64AC(v, a, x0, x1); // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
4159
-
4160
- // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
4161
- var xor0 = v[d] ^ v[a];
4162
- var xor1 = v[d + 1] ^ v[a + 1];
4163
- v[d] = xor1;
4164
- v[d + 1] = xor0;
4165
-
4166
- ADD64AA(v, c, d);
4167
-
4168
- // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
4169
- xor0 = v[b] ^ v[c];
4170
- xor1 = v[b + 1] ^ v[c + 1];
4171
- v[b] = (xor0 >>> 24) ^ (xor1 << 8);
4172
- v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8);
4173
-
4174
- ADD64AA(v, a, b);
4175
- ADD64AC(v, a, y0, y1);
4176
-
4177
- // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
4178
- xor0 = v[d] ^ v[a];
4179
- xor1 = v[d + 1] ^ v[a + 1];
4180
- v[d] = (xor0 >>> 16) ^ (xor1 << 16);
4181
- v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16);
4182
-
4183
- ADD64AA(v, c, d);
4184
-
4185
- // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
4186
- xor0 = v[b] ^ v[c];
4187
- xor1 = v[b + 1] ^ v[c + 1];
4188
- v[b] = (xor1 >>> 31) ^ (xor0 << 1);
4189
- v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1);
4190
- }
4191
-
4192
- // Initialization Vector
4193
- var BLAKE2B_IV32 = new Uint32Array([
4194
- 0xF3BCC908, 0x6A09E667, 0x84CAA73B, 0xBB67AE85,
4195
- 0xFE94F82B, 0x3C6EF372, 0x5F1D36F1, 0xA54FF53A,
4196
- 0xADE682D1, 0x510E527F, 0x2B3E6C1F, 0x9B05688C,
4197
- 0xFB41BD6B, 0x1F83D9AB, 0x137E2179, 0x5BE0CD19
4198
- ]);
4199
-
4200
- var SIGMA8 = [
4201
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
4202
- 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
4203
- 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
4204
- 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
4205
- 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
4206
- 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
4207
- 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
4208
- 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
4209
- 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
4210
- 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
4211
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
4212
- 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3
4213
- ];
4214
-
4215
- // These are offsets into a uint64 buffer.
4216
- // Multiply them all by 2 to make them offsets into a uint32 buffer,
4217
- // because this is Javascript and we don't have uint64s
4218
- var SIGMA82 = new Uint8Array(SIGMA8.map(function (x) { return x * 2 }));
4219
-
4220
- // Compression function. 'last' flag indicates last block.
4221
- // Note we're representing 16 uint64s as 32 uint32s
4222
- var v = new Uint32Array(32);
4223
- var m = new Uint32Array(32);
4224
- function blake2bCompress (ctx, last) {
4225
- var i = 0;
4226
-
4227
- // init work variables
4228
- for (i = 0; i < 16; i++) {
4229
- v[i] = ctx.h[i];
4230
- v[i + 16] = BLAKE2B_IV32[i];
4231
- }
4232
-
4233
- // low 64 bits of offset
4234
- v[24] = v[24] ^ ctx.t;
4235
- v[25] = v[25] ^ (ctx.t / 0x100000000);
4236
- // high 64 bits not supported, offset may not be higher than 2**53-1
4237
-
4238
- // last block flag set ?
4239
- if (last) {
4240
- v[28] = ~v[28];
4241
- v[29] = ~v[29];
4242
- }
4243
-
4244
- // get little-endian words
4245
- for (i = 0; i < 32; i++) {
4246
- m[i] = B2B_GET32(ctx.b, 4 * i);
4247
- }
4248
-
4249
- // twelve rounds of mixing
4250
- for (i = 0; i < 12; i++) {
4251
- B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
4252
- B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
4253
- B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
4254
- B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
4255
- B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
4256
- B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
4257
- B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
4258
- B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
4259
- }
4260
-
4261
- for (i = 0; i < 16; i++) {
4262
- ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
4263
- }
4264
- }
4265
-
4266
- // reusable parameter_block
4267
- var parameter_block = new Uint8Array([
4268
- 0, 0, 0, 0, // 0: outlen, keylen, fanout, depth
4269
- 0, 0, 0, 0, // 4: leaf length, sequential mode
4270
- 0, 0, 0, 0, // 8: node offset
4271
- 0, 0, 0, 0, // 12: node offset
4272
- 0, 0, 0, 0, // 16: node depth, inner length, rfu
4273
- 0, 0, 0, 0, // 20: rfu
4274
- 0, 0, 0, 0, // 24: rfu
4275
- 0, 0, 0, 0, // 28: rfu
4276
- 0, 0, 0, 0, // 32: salt
4277
- 0, 0, 0, 0, // 36: salt
4278
- 0, 0, 0, 0, // 40: salt
4279
- 0, 0, 0, 0, // 44: salt
4280
- 0, 0, 0, 0, // 48: personal
4281
- 0, 0, 0, 0, // 52: personal
4282
- 0, 0, 0, 0, // 56: personal
4283
- 0, 0, 0, 0 // 60: personal
4284
- ]);
4285
-
4286
- // Creates a BLAKE2b hashing context
4287
- // Requires an output length between 1 and 64 bytes
4288
- // Takes an optional Uint8Array key
4289
- function Blake2b (outlen, key, salt, personal) {
4290
- // zero out parameter_block before usage
4291
- parameter_block.fill(0);
4292
- // state, 'param block'
4293
-
4294
- this.b = new Uint8Array(128);
4295
- this.h = new Uint32Array(16);
4296
- this.t = 0; // input count
4297
- this.c = 0; // pointer within buffer
4298
- this.outlen = outlen; // output length in bytes
4299
-
4300
- parameter_block[0] = outlen;
4301
- if (key) parameter_block[1] = key.length;
4302
- parameter_block[2] = 1; // fanout
4303
- parameter_block[3] = 1; // depth
4304
-
4305
- if (salt) parameter_block.set(salt, 32);
4306
- if (personal) parameter_block.set(personal, 48);
4307
-
4308
- // initialize hash state
4309
- for (var i = 0; i < 16; i++) {
4310
- this.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameter_block, i * 4);
4311
- }
4312
-
4313
- // key the hash, if applicable
4314
- if (key) {
4315
- blake2bUpdate(this, key);
4316
- // at the end
4317
- this.c = 128;
4318
- }
4319
- }
4320
-
4321
- Blake2b.prototype.update = function (input) {
4322
- assert(input instanceof Uint8Array, 'input must be Uint8Array or Buffer');
4323
- blake2bUpdate(this, input);
4324
- return this
4325
- };
4326
-
4327
- Blake2b.prototype.digest = function (out) {
4328
- var buf = (!out || out === 'binary' || out === 'hex') ? new Uint8Array(this.outlen) : out;
4329
- assert(buf instanceof Uint8Array, 'out must be "binary", "hex", Uint8Array, or Buffer');
4330
- assert(buf.length >= this.outlen, 'out must have at least outlen bytes of space');
4331
- blake2bFinal(this, buf);
4332
- if (out === 'hex') return hexSlice(buf)
4333
- return buf
4334
- };
4335
-
4336
- Blake2b.prototype.final = Blake2b.prototype.digest;
4337
-
4338
- Blake2b.ready = function (cb) {
4339
- b2wasm.ready(function () {
4340
- cb(); // ignore the error
4341
- });
4342
- };
4343
-
4344
- // Updates a BLAKE2b streaming hash
4345
- // Requires hash context and Uint8Array (byte array)
4346
- function blake2bUpdate (ctx, input) {
4347
- for (var i = 0; i < input.length; i++) {
4348
- if (ctx.c === 128) { // buffer full ?
4349
- ctx.t += ctx.c; // add counters
4350
- blake2bCompress(ctx, false); // compress (not last)
4351
- ctx.c = 0; // counter to zero
4352
- }
4353
- ctx.b[ctx.c++] = input[i];
4354
- }
4355
- }
4356
-
4357
- // Completes a BLAKE2b streaming hash
4358
- // Returns a Uint8Array containing the message digest
4359
- function blake2bFinal (ctx, out) {
4360
- ctx.t += ctx.c; // mark last block offset
4361
-
4362
- while (ctx.c < 128) { // fill up with zeros
4363
- ctx.b[ctx.c++] = 0;
4364
- }
4365
- blake2bCompress(ctx, true); // final block flag = 1
4366
-
4367
- for (var i = 0; i < ctx.outlen; i++) {
4368
- out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
4369
- }
4370
- return out
4371
- }
4372
-
4373
- function hexSlice (buf) {
4374
- var str = '';
4375
- for (var i = 0; i < buf.length; i++) str += toHex(buf[i]);
4376
- return str
4377
- }
4378
-
4379
- function toHex (n) {
4380
- if (n < 16) return '0' + n.toString(16)
4381
- return n.toString(16)
4382
- }
4383
-
4384
- var Proto = Blake2b;
4385
-
4386
- blake2b$3.exports = function createHash (outlen, key, salt, personal, noAssert) {
4387
- if (noAssert !== true) {
4388
- assert(outlen >= BYTES_MIN, 'outlen must be at least ' + BYTES_MIN + ', was given ' + outlen);
4389
- assert(outlen <= BYTES_MAX, 'outlen must be at most ' + BYTES_MAX + ', was given ' + outlen);
4390
- if (key != null) {
4391
- assert(key instanceof Uint8Array, 'key must be Uint8Array or Buffer');
4392
- assert(key.length >= KEYBYTES_MIN, 'key must be at least ' + KEYBYTES_MIN + ', was given ' + key.length);
4393
- assert(key.length <= KEYBYTES_MAX, 'key must be at most ' + KEYBYTES_MAX + ', was given ' + key.length);
4394
- }
4395
- if (salt != null) {
4396
- assert(salt instanceof Uint8Array, 'salt must be Uint8Array or Buffer');
4397
- assert(salt.length === SALTBYTES, 'salt must be exactly ' + SALTBYTES + ', was given ' + salt.length);
4398
- }
4399
- if (personal != null) {
4400
- assert(personal instanceof Uint8Array, 'personal must be Uint8Array or Buffer');
4401
- assert(personal.length === PERSONALBYTES, 'personal must be exactly ' + PERSONALBYTES + ', was given ' + personal.length);
4402
- }
4403
- }
4404
-
4405
- return new Proto(outlen, key, salt, personal)
4406
- };
4407
-
4408
- blake2b$3.exports.ready = function (cb) {
4409
- b2wasm.ready(function () { // ignore errors
4410
- cb();
4411
- });
4412
- };
4413
-
4414
- blake2b$3.exports.WASM_SUPPORTED = b2wasm.SUPPORTED;
4415
- blake2b$3.exports.WASM_LOADED = false;
4416
-
4417
- var BYTES_MIN = blake2b$3.exports.BYTES_MIN = 16;
4418
- var BYTES_MAX = blake2b$3.exports.BYTES_MAX = 64;
4419
- blake2b$3.exports.BYTES = 32;
4420
- var KEYBYTES_MIN = blake2b$3.exports.KEYBYTES_MIN = 16;
4421
- var KEYBYTES_MAX = blake2b$3.exports.KEYBYTES_MAX = 64;
4422
- blake2b$3.exports.KEYBYTES = 32;
4423
- var SALTBYTES = blake2b$3.exports.SALTBYTES = 16;
4424
- var PERSONALBYTES = blake2b$3.exports.PERSONALBYTES = 16;
4425
-
4426
- b2wasm.ready(function (err) {
4427
- if (!err) {
4428
- blake2b$3.exports.WASM_LOADED = true;
4429
- blake2b$3.exports = b2wasm;
4430
- }
4431
- });
4432
- return blake2b$3.exports;
3679
+ function deriveEd25519SecretKey(seed, blake2b) {
3680
+ return blake2b.hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw])).asOpaque();
4433
3681
  }
4434
-
4435
- var blake2bExports = /*@__PURE__*/ requireBlake2b();
4436
- var blake2b$1 = /*@__PURE__*/getDefaultExportFromCjs(blake2bExports);
4437
-
4438
3682
  /**
4439
- * Hash given collection of blobs.
4440
- *
4441
- * If empty array is given a zero-hash is returned.
3683
+ * Derives a Bandersnatch secret key from a seed.
3684
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
4442
3685
  */
4443
- function hashBlobs$1(r, allocator = defaultAllocator) {
4444
- const out = allocator.emptyHash();
4445
- if (r.length === 0) {
4446
- return out.asOpaque();
4447
- }
4448
- const hasher = blake2b$1(HASH_SIZE);
4449
- for (const v of r) {
4450
- hasher?.update(v instanceof BytesBlob ? v.raw : v);
4451
- }
4452
- hasher?.digest(out.raw);
4453
- return out.asOpaque();
3686
+ function deriveBandersnatchSecretKey(seed, blake2b) {
3687
+ return blake2b.hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw])).asOpaque();
4454
3688
  }
4455
- /** Hash given blob of bytes. */
4456
- function hashBytes(blob, allocator = defaultAllocator) {
4457
- const hasher = blake2b$1(HASH_SIZE);
4458
- const bytes = blob instanceof BytesBlob ? blob.raw : blob;
4459
- hasher?.update(bytes);
4460
- const out = allocator.emptyHash();
4461
- hasher?.digest(out.raw);
4462
- return out;
3689
+ /**
3690
+ * Derive Ed25519 public key from secret seed
3691
+ */
3692
+ async function deriveEd25519PublicKey(seed) {
3693
+ return (await privateKey(seed)).pubKey;
4463
3694
  }
4464
- /** Convert given string into bytes and hash it. */
4465
- function hashString(str, allocator = defaultAllocator) {
4466
- return hashBytes(BytesBlob.blobFromString(str), allocator);
3695
+ /**
3696
+ * Derive Bandersnatch public key from secret seed
3697
+ */
3698
+ function deriveBandersnatchPublicKey(seed) {
3699
+ return publicKey(seed.raw);
4467
3700
  }
4468
3701
 
4469
- var blake2b = /*#__PURE__*/Object.freeze({
3702
+ var keyDerivation = /*#__PURE__*/Object.freeze({
3703
+ __proto__: null,
3704
+ SEED_SIZE: SEED_SIZE,
3705
+ deriveBandersnatchPublicKey: deriveBandersnatchPublicKey,
3706
+ deriveBandersnatchSecretKey: deriveBandersnatchSecretKey,
3707
+ deriveEd25519PublicKey: deriveEd25519PublicKey,
3708
+ deriveEd25519SecretKey: deriveEd25519SecretKey,
3709
+ trivialSeed: trivialSeed
3710
+ });
3711
+
3712
+ var index$p = /*#__PURE__*/Object.freeze({
4470
3713
  __proto__: null,
4471
- hashBlobs: hashBlobs$1,
4472
- hashBytes: hashBytes,
4473
- hashString: hashString
3714
+ BANDERSNATCH_KEY_BYTES: BANDERSNATCH_KEY_BYTES,
3715
+ BANDERSNATCH_PROOF_BYTES: BANDERSNATCH_PROOF_BYTES,
3716
+ BANDERSNATCH_RING_ROOT_BYTES: BANDERSNATCH_RING_ROOT_BYTES,
3717
+ BANDERSNATCH_VRF_SIGNATURE_BYTES: BANDERSNATCH_VRF_SIGNATURE_BYTES,
3718
+ BLS_KEY_BYTES: BLS_KEY_BYTES,
3719
+ ED25519_KEY_BYTES: ED25519_KEY_BYTES,
3720
+ ED25519_PRIV_KEY_BYTES: ED25519_PRIV_KEY_BYTES,
3721
+ ED25519_SIGNATURE_BYTES: ED25519_SIGNATURE_BYTES,
3722
+ Ed25519Pair: Ed25519Pair,
3723
+ SEED_SIZE: SEED_SIZE,
3724
+ bandersnatch: bandersnatch,
3725
+ bandersnatchWasm: bandersnatch_exports,
3726
+ ed25519: ed25519,
3727
+ initWasm: initAll,
3728
+ keyDerivation: keyDerivation
4474
3729
  });
4475
3730
 
4476
3731
  /*!
@@ -4831,26 +4086,97 @@ function WASMInterface(binary, hashLength) {
4831
4086
 
4832
4087
  new Mutex();
4833
4088
 
4834
- new Mutex();
4835
-
4836
- new Mutex();
4837
-
4838
- new Mutex();
4839
-
4840
- new Mutex();
4841
-
4842
- new Mutex();
4843
-
4844
- new Mutex();
4845
-
4846
- new Mutex();
4089
+ var name$j = "blake2b";
4090
+ var data$j = "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";
4091
+ var hash$j = "c6f286e6";
4092
+ var wasmJson$j = {
4093
+ name: name$j,
4094
+ data: data$j,
4095
+ hash: hash$j
4096
+ };
4847
4097
 
4848
4098
  new Mutex();
4849
-
4850
- var name$b = "sha3";
4851
- var data$b = "AGFzbQEAAAABFARgAAF/YAF/AGACf38AYAN/f38AAwgHAAEBAgEAAwUEAQECAgYOAn8BQZCNBQt/AEGACAsHcAgGbWVtb3J5AgAOSGFzaF9HZXRCdWZmZXIAAAlIYXNoX0luaXQAAQtIYXNoX1VwZGF0ZQACCkhhc2hfRmluYWwABA1IYXNoX0dldFN0YXRlAAUOSGFzaF9DYWxjdWxhdGUABgpTVEFURV9TSVpFAwEKpBwHBQBBgAoL1wMAQQBCADcDgI0BQQBCADcD+IwBQQBCADcD8IwBQQBCADcD6IwBQQBCADcD4IwBQQBCADcD2IwBQQBCADcD0IwBQQBCADcDyIwBQQBCADcDwIwBQQBCADcDuIwBQQBCADcDsIwBQQBCADcDqIwBQQBCADcDoIwBQQBCADcDmIwBQQBCADcDkIwBQQBCADcDiIwBQQBCADcDgIwBQQBCADcD+IsBQQBCADcD8IsBQQBCADcD6IsBQQBCADcD4IsBQQBCADcD2IsBQQBCADcD0IsBQQBCADcDyIsBQQBCADcDwIsBQQBCADcDuIsBQQBCADcDsIsBQQBCADcDqIsBQQBCADcDoIsBQQBCADcDmIsBQQBCADcDkIsBQQBCADcDiIsBQQBCADcDgIsBQQBCADcD+IoBQQBCADcD8IoBQQBCADcD6IoBQQBCADcD4IoBQQBCADcD2IoBQQBCADcD0IoBQQBCADcDyIoBQQBCADcDwIoBQQBCADcDuIoBQQBCADcDsIoBQQBCADcDqIoBQQBCADcDoIoBQQBCADcDmIoBQQBCADcDkIoBQQBCADcDiIoBQQBCADcDgIoBQQBBwAwgAEEBdGtBA3Y2AoyNAUEAQQA2AoiNAQuMAwEIfwJAQQAoAoiNASIBQQBIDQBBACABIABqQQAoAoyNASICcDYCiI0BAkACQCABDQBBgAohAwwBCwJAIAIgAWsiBCAAIAQgAEkbIgNFDQAgA0EDcSEFQQAhBgJAIANBBEkNACABQYCKAWohByADQXxxIQhBACEGA0AgByAGaiIDQcgBaiAGQYAKai0AADoAACADQckBaiAGQYEKai0AADoAACADQcoBaiAGQYIKai0AADoAACADQcsBaiAGQYMKai0AADoAACAIIAZBBGoiBkcNAAsLIAVFDQAgAUHIiwFqIQMDQCADIAZqIAZBgApqLQAAOgAAIAZBAWohBiAFQX9qIgUNAAsLIAAgBEkNAUHIiwEgAhADIAAgBGshACAEQYAKaiEDCwJAIAAgAkkNAANAIAMgAhADIAMgAmohAyAAIAJrIgAgAk8NAAsLIABFDQBBACECQcgBIQYDQCAGQYCKAWogAyAGakG4fmotAAA6AAAgBkEBaiEGIAAgAkEBaiICQf8BcUsNAAsLC+ALAS1+IAApA0AhAkEAKQPAigEhAyAAKQM4IQRBACkDuIoBIQUgACkDMCEGQQApA7CKASEHIAApAyghCEEAKQOoigEhCSAAKQMgIQpBACkDoIoBIQsgACkDGCEMQQApA5iKASENIAApAxAhDkEAKQOQigEhDyAAKQMIIRBBACkDiIoBIREgACkDACESQQApA4CKASETQQApA8iKASEUAkACQCABQcgASw0AQQApA+iKASEVQQApA/iKASEWQQApA/CKASEXQQApA4CLASEYQQApA9CKASEZQQApA+CKASEaQQApA9iKASEbDAELQQApA+CKASAAKQNghSEaQQApA9iKASAAKQNYhSEbQQApA9CKASAAKQNQhSEZIBQgACkDSIUhFEEAKQPoigEhFUEAKQP4igEhFkEAKQPwigEhF0EAKQOAiwEhGCABQekASQ0AIBggACkDgAGFIRggFiAAKQN4hSEWIBcgACkDcIUhFyAVIAApA2iFIRUgAUGJAUkNAEEAQQApA4iLASAAKQOIAYU3A4iLAQsgAyAChSEcIAUgBIUhHSAHIAaFIQcgCSAIhSEIIAsgCoUhHiANIAyFIQkgDyAOhSEKIBEgEIUhCyATIBKFIQxBACkDuIsBIRBBACkDkIsBIRFBACkDoIsBIRJBACkDsIsBIRNBACkDiIsBIQ1BACkDwIsBIQ5BACkDmIsBIR9BACkDqIsBIQ9BwH4hAANAIB4gByALhSAbhSAYhSAPhUIBiYUgFIUgF4UgH4UgDoUhAiAMIB0gCoUgGoUgDYUgE4VCAYmFIAiFIBmFIBaFIBKFIgMgB4UhICAJIAggDIUgGYUgFoUgEoVCAYmFIByFIBWFIBGFIBCFIgQgDoUhISAcIAogFCAehSAXhSAfhSAOhUIBiYUgHYUgGoUgDYUgE4UiBYVCN4kiIiALIBwgCYUgFYUgEYUgEIVCAYmFIAeFIBuFIBiFIA+FIgYgCoVCPokiI0J/hYMgAyAPhUICiSIkhSEOIBYgAoVCKYkiJSAEIBeFQieJIiZCf4WDICKFIQ8gECAFhUI4iSIQIAYgDYVCD4kiJ0J/hYMgAyAbhUIKiSIohSENIAQgHoVCG4kiKSAoIAggAoVCJIkiKkJ/hYOFIRYgBiAdhUIGiSIrIAMgC4VCAYkiLEJ/hYMgEiAChUISiSIthSEXICsgBCAfhUIIiSIuIBUgBYVCGYkiFUJ/hYOFIRsgBiAThUI9iSIdIAQgFIVCFIkiBCAJIAWFQhyJIghCf4WDhSEUIAggHUJ/hYMgAyAYhUItiSIDhSEcIB0gA0J/hYMgGSAChUIDiSIJhSEdIAQgAyAJQn+Fg4UhByAJIARCf4WDIAiFIQggDCAChSICICFCDokiA0J/hYMgESAFhUIViSIEhSEJIAYgGoVCK4kiBSADIARCf4WDhSEKIAQgBUJ/hYMgIEIsiSIEhSELIABB0AlqKQMAIAUgBEJ/hYOFIAKFIQwgJyAoQn+FgyAqhSIFIRggAyAEIAJCf4WDhSICIR4gKiApQn+FgyAQhSIDIR8gLSAuQn+FgyAVhSIEIRogJiAkICVCf4WDhSIGIRMgFSArQn+FgyAshSIoIRkgIyAmICJCf4WDhSIiIRIgLiAsIC1Cf4WDhSImIRUgJyApIBBCf4WDhSInIREgIyAkQn+FgyAlhSIjIRAgAEEIaiIADQALQQAgDzcDqIsBQQAgBTcDgIsBQQAgGzcD2IoBQQAgBzcDsIoBQQAgCzcDiIoBQQAgDjcDwIsBQQAgAzcDmIsBQQAgFzcD8IoBQQAgFDcDyIoBQQAgAjcDoIoBQQAgBjcDsIsBQQAgDTcDiIsBQQAgBDcD4IoBQQAgHTcDuIoBQQAgCjcDkIoBQQAgIjcDoIsBQQAgFjcD+IoBQQAgKDcD0IoBQQAgCDcDqIoBQQAgDDcDgIoBQQAgIzcDuIsBQQAgJzcDkIsBQQAgJjcD6IoBQQAgHDcDwIoBQQAgCTcDmIoBC/gCAQV/QeQAQQAoAoyNASIBQQF2ayECAkBBACgCiI0BIgNBAEgNACABIQQCQCABIANGDQAgA0HIiwFqIQVBACEDA0AgBSADakEAOgAAIANBAWoiAyABQQAoAoiNASIEa0kNAAsLIARByIsBaiIDIAMtAAAgAHI6AAAgAUHHiwFqIgMgAy0AAEGAAXI6AABByIsBIAEQA0EAQYCAgIB4NgKIjQELAkAgAkEESQ0AIAJBAnYiA0EDcSEFQQAhBAJAIANBf2pBA0kNACADQfz///8DcSEBQQAhA0EAIQQDQCADQYAKaiADQYCKAWooAgA2AgAgA0GECmogA0GEigFqKAIANgIAIANBiApqIANBiIoBaigCADYCACADQYwKaiADQYyKAWooAgA2AgAgA0EQaiEDIAEgBEEEaiIERw0ACwsgBUUNACAFQQJ0IQEgBEECdCEDA0AgA0GACmogA0GAigFqKAIANgIAIANBBGohAyABQXxqIgENAAsLCwYAQYCKAQvRBgEDf0EAQgA3A4CNAUEAQgA3A/iMAUEAQgA3A/CMAUEAQgA3A+iMAUEAQgA3A+CMAUEAQgA3A9iMAUEAQgA3A9CMAUEAQgA3A8iMAUEAQgA3A8CMAUEAQgA3A7iMAUEAQgA3A7CMAUEAQgA3A6iMAUEAQgA3A6CMAUEAQgA3A5iMAUEAQgA3A5CMAUEAQgA3A4iMAUEAQgA3A4CMAUEAQgA3A/iLAUEAQgA3A/CLAUEAQgA3A+iLAUEAQgA3A+CLAUEAQgA3A9iLAUEAQgA3A9CLAUEAQgA3A8iLAUEAQgA3A8CLAUEAQgA3A7iLAUEAQgA3A7CLAUEAQgA3A6iLAUEAQgA3A6CLAUEAQgA3A5iLAUEAQgA3A5CLAUEAQgA3A4iLAUEAQgA3A4CLAUEAQgA3A/iKAUEAQgA3A/CKAUEAQgA3A+iKAUEAQgA3A+CKAUEAQgA3A9iKAUEAQgA3A9CKAUEAQgA3A8iKAUEAQgA3A8CKAUEAQgA3A7iKAUEAQgA3A7CKAUEAQgA3A6iKAUEAQgA3A6CKAUEAQgA3A5iKAUEAQgA3A5CKAUEAQgA3A4iKAUEAQgA3A4CKAUEAQcAMIAFBAXRrQQN2NgKMjQFBAEEANgKIjQEgABACQeQAQQAoAoyNASIAQQF2ayEDAkBBACgCiI0BIgFBAEgNACAAIQQCQCAAIAFGDQAgAUHIiwFqIQVBACEBA0AgBSABakEAOgAAIAFBAWoiASAAQQAoAoiNASIEa0kNAAsLIARByIsBaiIBIAEtAAAgAnI6AAAgAEHHiwFqIgEgAS0AAEGAAXI6AABByIsBIAAQA0EAQYCAgIB4NgKIjQELAkAgA0EESQ0AIANBAnYiAUEDcSEFQQAhBAJAIAFBf2pBA0kNACABQfz///8DcSEAQQAhAUEAIQQDQCABQYAKaiABQYCKAWooAgA2AgAgAUGECmogAUGEigFqKAIANgIAIAFBiApqIAFBiIoBaigCADYCACABQYwKaiABQYyKAWooAgA2AgAgAUEQaiEBIAAgBEEEaiIERw0ACwsgBUUNACAFQQJ0IQAgBEECdCEBA0AgAUGACmogAUGAigFqKAIANgIAIAFBBGohASAAQXxqIgANAAsLCwvYAQEAQYAIC9ABkAEAAAAAAAAAAAAAAAAAAAEAAAAAAAAAgoAAAAAAAACKgAAAAAAAgACAAIAAAACAi4AAAAAAAAABAACAAAAAAIGAAIAAAACACYAAAAAAAICKAAAAAAAAAIgAAAAAAAAACYAAgAAAAAAKAACAAAAAAIuAAIAAAAAAiwAAAAAAAICJgAAAAAAAgAOAAAAAAACAAoAAAAAAAICAAAAAAAAAgAqAAAAAAAAACgAAgAAAAICBgACAAAAAgICAAAAAAACAAQAAgAAAAAAIgACAAAAAgA==";
4852
- var hash$b = "fb24e536";
4853
- var wasmJson$b = {
4099
+ function validateBits$4(bits) {
4100
+ if (!Number.isInteger(bits) || bits < 8 || bits > 512 || bits % 8 !== 0) {
4101
+ return new Error("Invalid variant! Valid values: 8, 16, ..., 512");
4102
+ }
4103
+ return null;
4104
+ }
4105
+ function getInitParam$1(outputBits, keyBits) {
4106
+ return outputBits | (keyBits << 16);
4107
+ }
4108
+ /**
4109
+ * Creates a new BLAKE2b hash instance
4110
+ * @param bits Number of output bits, which has to be a number
4111
+ * divisible by 8, between 8 and 512. Defaults to 512.
4112
+ * @param key Optional key (string, Buffer or TypedArray). Maximum length is 64 bytes.
4113
+ */
4114
+ function createBLAKE2b(bits = 512, key = null) {
4115
+ if (validateBits$4(bits)) {
4116
+ return Promise.reject(validateBits$4(bits));
4117
+ }
4118
+ let keyBuffer = null;
4119
+ let initParam = bits;
4120
+ if (key !== null) {
4121
+ keyBuffer = getUInt8Buffer(key);
4122
+ if (keyBuffer.length > 64) {
4123
+ return Promise.reject(new Error("Max key length is 64 bytes"));
4124
+ }
4125
+ initParam = getInitParam$1(bits, keyBuffer.length);
4126
+ }
4127
+ const outputSize = bits / 8;
4128
+ return WASMInterface(wasmJson$j, outputSize).then((wasm) => {
4129
+ if (initParam > 512) {
4130
+ wasm.writeMemory(keyBuffer);
4131
+ }
4132
+ wasm.init(initParam);
4133
+ const obj = {
4134
+ init: initParam > 512
4135
+ ? () => {
4136
+ wasm.writeMemory(keyBuffer);
4137
+ wasm.init(initParam);
4138
+ return obj;
4139
+ }
4140
+ : () => {
4141
+ wasm.init(initParam);
4142
+ return obj;
4143
+ },
4144
+ update: (data) => {
4145
+ wasm.update(data);
4146
+ return obj;
4147
+ },
4148
+ // biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
4149
+ digest: (outputType) => wasm.digest(outputType),
4150
+ save: () => wasm.save(),
4151
+ load: (data) => {
4152
+ wasm.load(data);
4153
+ return obj;
4154
+ },
4155
+ blockSize: 128,
4156
+ digestSize: outputSize,
4157
+ };
4158
+ return obj;
4159
+ });
4160
+ }
4161
+
4162
+ new Mutex();
4163
+
4164
+ new Mutex();
4165
+
4166
+ new Mutex();
4167
+
4168
+ new Mutex();
4169
+
4170
+ new Mutex();
4171
+
4172
+ new Mutex();
4173
+
4174
+ new Mutex();
4175
+
4176
+ var name$b = "sha3";
4177
+ var data$b = "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";
4178
+ var hash$b = "fb24e536";
4179
+ var wasmJson$b = {
4854
4180
  name: name$b,
4855
4181
  data: data$b,
4856
4182
  hash: hash$b
@@ -4921,6 +4247,79 @@ new Mutex();
4921
4247
 
4922
4248
  new Mutex();
4923
4249
 
4250
+ /**
4251
+ * Size of the output of the hash functions.
4252
+ *
4253
+ * https://graypaper.fluffylabs.dev/#/579bd12/073101073c01
4254
+ *
4255
+ */
4256
+ const HASH_SIZE = 32;
4257
+ /** A hash without last byte (useful for trie representation). */
4258
+ const TRUNCATED_HASH_SIZE = 31;
4259
+ const ZERO_HASH = Bytes.zero(HASH_SIZE);
4260
+ /**
4261
+ * Container for some object with a hash that is related to this object.
4262
+ *
4263
+ * After calculating the hash these two should be passed together to avoid
4264
+ * unnecessary re-hashing of the data.
4265
+ */
4266
+ class WithHash extends WithDebug {
4267
+ hash;
4268
+ data;
4269
+ constructor(hash, data) {
4270
+ super();
4271
+ this.hash = hash;
4272
+ this.data = data;
4273
+ }
4274
+ }
4275
+ /**
4276
+ * Extension of [`WithHash`] additionally containing an encoded version of the object.
4277
+ */
4278
+ class WithHashAndBytes extends WithHash {
4279
+ encoded;
4280
+ constructor(hash, data, encoded) {
4281
+ super(hash, data);
4282
+ this.encoded = encoded;
4283
+ }
4284
+ }
4285
+
4286
+ const zero$1 = Bytes.zero(HASH_SIZE);
4287
+ class Blake2b {
4288
+ hasher;
4289
+ static async createHasher() {
4290
+ return new Blake2b(await createBLAKE2b(HASH_SIZE * 8));
4291
+ }
4292
+ constructor(hasher) {
4293
+ this.hasher = hasher;
4294
+ }
4295
+ /**
4296
+ * Hash given collection of blobs.
4297
+ *
4298
+ * If empty array is given a zero-hash is returned.
4299
+ */
4300
+ hashBlobs(r) {
4301
+ if (r.length === 0) {
4302
+ return zero$1.asOpaque();
4303
+ }
4304
+ const hasher = this.hasher.init();
4305
+ for (const v of r) {
4306
+ hasher.update(v instanceof BytesBlob ? v.raw : v);
4307
+ }
4308
+ return Bytes.fromBlob(hasher.digest("binary"), HASH_SIZE).asOpaque();
4309
+ }
4310
+ /** Hash given blob of bytes. */
4311
+ hashBytes(blob) {
4312
+ const hasher = this.hasher.init();
4313
+ const bytes = blob instanceof BytesBlob ? blob.raw : blob;
4314
+ hasher.update(bytes);
4315
+ return Bytes.fromBlob(hasher.digest("binary"), HASH_SIZE).asOpaque();
4316
+ }
4317
+ /** Convert given string into bytes and hash it. */
4318
+ hashString(str) {
4319
+ return this.hashBytes(BytesBlob.blobFromString(str));
4320
+ }
4321
+ }
4322
+
4924
4323
  class KeccakHasher {
4925
4324
  hasher;
4926
4325
  static async create() {
@@ -4945,91 +4344,61 @@ var keccak = /*#__PURE__*/Object.freeze({
4945
4344
  hashBlobs: hashBlobs
4946
4345
  });
4947
4346
 
4948
- var index$p = /*#__PURE__*/Object.freeze({
4347
+ // TODO [ToDr] (#213) this should most likely be moved to a separate
4348
+ // package to avoid pulling in unnecessary deps.
4349
+
4350
+ var index$o = /*#__PURE__*/Object.freeze({
4949
4351
  __proto__: null,
4352
+ Blake2b: Blake2b,
4950
4353
  HASH_SIZE: HASH_SIZE,
4951
- PageAllocator: PageAllocator,
4952
- SimpleAllocator: SimpleAllocator,
4953
4354
  TRUNCATED_HASH_SIZE: TRUNCATED_HASH_SIZE,
4954
4355
  WithHash: WithHash,
4955
4356
  WithHashAndBytes: WithHashAndBytes,
4956
4357
  ZERO_HASH: ZERO_HASH,
4957
- blake2b: blake2b,
4958
- defaultAllocator: defaultAllocator,
4959
4358
  keccak: keccak
4960
4359
  });
4961
4360
 
4962
- const SEED_SIZE = 32;
4963
- const ED25519_SECRET_KEY = Bytes.blobFromString("jam_val_key_ed25519");
4964
- const BANDERSNATCH_SECRET_KEY = Bytes.blobFromString("jam_val_key_bandersnatch");
4965
- /**
4966
- * JIP-5: Secret key derivation
4967
- *
4968
- * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md */
4969
- /**
4970
- * Deriving a 32-byte seed from a 32-bit unsigned integer
4971
- * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#trivial-seeds
4972
- */
4973
- function trivialSeed(s) {
4974
- const s_le = u32AsLeBytes(s);
4975
- return Bytes.fromBlob(BytesBlob.blobFromParts([s_le, s_le, s_le, s_le, s_le, s_le, s_le, s_le]).raw, SEED_SIZE).asOpaque();
4976
- }
4977
- /**
4978
- * Derives a Ed25519 secret key from a seed.
4979
- * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
4980
- */
4981
- function deriveEd25519SecretKey(seed, allocator = new SimpleAllocator()) {
4982
- return hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw]), allocator).asOpaque();
4983
- }
4984
- /**
4985
- * Derives a Bandersnatch secret key from a seed.
4986
- * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
4987
- */
4988
- function deriveBandersnatchSecretKey(seed, allocator = new SimpleAllocator()) {
4989
- return hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw]), allocator).asOpaque();
4990
- }
4991
- /**
4992
- * Derive Ed25519 public key from secret seed
4993
- */
4994
- async function deriveEd25519PublicKey(seed) {
4995
- return (await privateKey(seed)).pubKey;
4996
- }
4997
4361
  /**
4998
- * Derive Bandersnatch public key from secret seed
4362
+ * A utility class providing a readonly view over a portion of an array without copying it.
4999
4363
  */
5000
- function deriveBandersnatchPublicKey(seed) {
5001
- return publicKey(seed.raw);
4364
+ class ArrayView {
4365
+ start;
4366
+ end;
4367
+ source;
4368
+ length;
4369
+ constructor(source, start, end) {
4370
+ this.start = start;
4371
+ this.end = end;
4372
+ this.source = source;
4373
+ this.length = end - start;
4374
+ }
4375
+ static from(source, start = 0, end = source.length) {
4376
+ check `
4377
+ ${start >= 0 && end <= source.length && start <= end}
4378
+ Invalid start (${start})/end (${end}) for ArrayView
4379
+ `;
4380
+ return new ArrayView(source, start, end);
4381
+ }
4382
+ get(i) {
4383
+ check `
4384
+ ${i >= 0 && i < this.length}
4385
+ Index out of bounds: ${i} < ${this.length}
4386
+ `;
4387
+ return this.source[this.start + i];
4388
+ }
4389
+ subview(from, to = this.length) {
4390
+ return ArrayView.from(this.source, this.start + from, this.start + to);
4391
+ }
4392
+ toArray() {
4393
+ return this.source.slice(this.start, this.end);
4394
+ }
4395
+ *[Symbol.iterator]() {
4396
+ for (let i = this.start; i < this.end; i++) {
4397
+ yield this.source[i];
4398
+ }
4399
+ }
5002
4400
  }
5003
4401
 
5004
- var keyDerivation = /*#__PURE__*/Object.freeze({
5005
- __proto__: null,
5006
- SEED_SIZE: SEED_SIZE,
5007
- deriveBandersnatchPublicKey: deriveBandersnatchPublicKey,
5008
- deriveBandersnatchSecretKey: deriveBandersnatchSecretKey,
5009
- deriveEd25519PublicKey: deriveEd25519PublicKey,
5010
- deriveEd25519SecretKey: deriveEd25519SecretKey,
5011
- trivialSeed: trivialSeed
5012
- });
5013
-
5014
- var index$o = /*#__PURE__*/Object.freeze({
5015
- __proto__: null,
5016
- BANDERSNATCH_KEY_BYTES: BANDERSNATCH_KEY_BYTES,
5017
- BANDERSNATCH_PROOF_BYTES: BANDERSNATCH_PROOF_BYTES,
5018
- BANDERSNATCH_RING_ROOT_BYTES: BANDERSNATCH_RING_ROOT_BYTES,
5019
- BANDERSNATCH_VRF_SIGNATURE_BYTES: BANDERSNATCH_VRF_SIGNATURE_BYTES,
5020
- BLS_KEY_BYTES: BLS_KEY_BYTES,
5021
- ED25519_KEY_BYTES: ED25519_KEY_BYTES,
5022
- ED25519_PRIV_KEY_BYTES: ED25519_PRIV_KEY_BYTES,
5023
- ED25519_SIGNATURE_BYTES: ED25519_SIGNATURE_BYTES,
5024
- Ed25519Pair: Ed25519Pair,
5025
- SEED_SIZE: SEED_SIZE,
5026
- bandersnatch: bandersnatch,
5027
- bandersnatchWasm: bandersnatch_exports,
5028
- ed25519: ed25519,
5029
- initWasm: initAll,
5030
- keyDerivation: keyDerivation
5031
- });
5032
-
5033
4402
  /** A map which uses hashes as keys. */
5034
4403
  class HashDictionary {
5035
4404
  // TODO [ToDr] [crit] We can't use `TrieHash` directly in the map,
@@ -5617,6 +4986,7 @@ class TruncatedHashDictionary {
5617
4986
 
5618
4987
  var index$n = /*#__PURE__*/Object.freeze({
5619
4988
  __proto__: null,
4989
+ ArrayView: ArrayView,
5620
4990
  FixedSizeArray: FixedSizeArray,
5621
4991
  HashDictionary: HashDictionary,
5622
4992
  HashSet: HashSet,
@@ -8578,43 +7948,43 @@ var stateKeys;
8578
7948
  }
8579
7949
  stateKeys.serviceInfo = serviceInfo;
8580
7950
  /** https://graypaper.fluffylabs.dev/#/1c979cb/3bba033bba03?v=0.7.1 */
8581
- function serviceStorage(serviceId, key) {
7951
+ function serviceStorage(blake2b, serviceId, key) {
8582
7952
  if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
8583
7953
  const out = Bytes.zero(HASH_SIZE);
8584
7954
  out.raw.set(u32AsLeBytes(tryAsU32(2 ** 32 - 1)), 0);
8585
7955
  out.raw.set(key.raw.subarray(0, HASH_SIZE - U32_BYTES), U32_BYTES);
8586
7956
  return legacyServiceNested(serviceId, out);
8587
7957
  }
8588
- return serviceNested(serviceId, tryAsU32(2 ** 32 - 1), key);
7958
+ return serviceNested(blake2b, serviceId, tryAsU32(2 ** 32 - 1), key);
8589
7959
  }
8590
7960
  stateKeys.serviceStorage = serviceStorage;
8591
7961
  /** https://graypaper.fluffylabs.dev/#/1c979cb/3bd7033bd703?v=0.7.1 */
8592
- function servicePreimage(serviceId, hash) {
7962
+ function servicePreimage(blake2b, serviceId, hash) {
8593
7963
  if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
8594
7964
  const out = Bytes.zero(HASH_SIZE);
8595
7965
  out.raw.set(u32AsLeBytes(tryAsU32(2 ** 32 - 2)), 0);
8596
7966
  out.raw.set(hash.raw.subarray(1, HASH_SIZE - U32_BYTES + 1), U32_BYTES);
8597
7967
  return legacyServiceNested(serviceId, out);
8598
7968
  }
8599
- return serviceNested(serviceId, tryAsU32(2 ** 32 - 2), hash);
7969
+ return serviceNested(blake2b, serviceId, tryAsU32(2 ** 32 - 2), hash);
8600
7970
  }
8601
7971
  stateKeys.servicePreimage = servicePreimage;
8602
7972
  /** https://graypaper.fluffylabs.dev/#/1c979cb/3b0a043b0a04?v=0.7.1 */
8603
- function serviceLookupHistory(serviceId, hash, preimageLength) {
7973
+ function serviceLookupHistory(blake2b, serviceId, hash, preimageLength) {
8604
7974
  if (Compatibility.isLessThan(GpVersion.V0_6_7)) {
8605
- const doubleHash = hashBytes(hash);
7975
+ const doubleHash = blake2b.hashBytes(hash);
8606
7976
  const out = Bytes.zero(HASH_SIZE);
8607
7977
  out.raw.set(u32AsLeBytes(preimageLength), 0);
8608
7978
  out.raw.set(doubleHash.raw.subarray(2, HASH_SIZE - U32_BYTES + 2), U32_BYTES);
8609
7979
  return legacyServiceNested(serviceId, out);
8610
7980
  }
8611
- return serviceNested(serviceId, preimageLength, hash);
7981
+ return serviceNested(blake2b, serviceId, preimageLength, hash);
8612
7982
  }
8613
7983
  stateKeys.serviceLookupHistory = serviceLookupHistory;
8614
7984
  /** https://graypaper.fluffylabs.dev/#/1c979cb/3b88003b8800?v=0.7.1 */
8615
- function serviceNested(serviceId, numberPrefix, hash) {
7985
+ function serviceNested(blake2b, serviceId, numberPrefix, hash) {
8616
7986
  const inputToHash = BytesBlob.blobFromParts(u32AsLeBytes(numberPrefix), hash.raw);
8617
- const newHash = hashBytes(inputToHash).raw.subarray(0, 28);
7987
+ const newHash = blake2b.hashBytes(inputToHash).raw.subarray(0, 28);
8618
7988
  const key = Bytes.zero(HASH_SIZE);
8619
7989
  let i = 0;
8620
7990
  for (const byte of u32AsLeBytes(serviceId)) {
@@ -8675,12 +8045,6 @@ function accumulationOutputComparator(a, b) {
8675
8045
  return Ordering.Equal;
8676
8046
  }
8677
8047
 
8678
- const codecWithHash = (val) => Descriptor.withView(val.name, val.sizeHint, (e, elem) => val.encode(e, elem.data), (d) => {
8679
- const decoder2 = d.clone();
8680
- const encoded = val.skipEncoded(decoder2);
8681
- const hash = hashBytes(encoded);
8682
- return new WithHash(hash.asOpaque(), val.decode(d));
8683
- }, val.skip, val.View);
8684
8048
  /**
8685
8049
  * Assignment of particular work report to a core.
8686
8050
  *
@@ -8693,7 +8057,7 @@ class AvailabilityAssignment extends WithDebug {
8693
8057
  workReport;
8694
8058
  timeout;
8695
8059
  static Codec = codec$1.Class(AvailabilityAssignment, {
8696
- workReport: codecWithHash(WorkReport.Codec),
8060
+ workReport: WorkReport.Codec,
8697
8061
  timeout: codec$1.u32.asOpaque(),
8698
8062
  });
8699
8063
  static create({ workReport, timeout }) {
@@ -8780,28 +8144,215 @@ class DisputesRecords {
8780
8144
  return new DisputesRecords(SortedSet.fromSortedArray(hashComparator, goodSet), SortedSet.fromSortedArray(hashComparator, badSet), SortedSet.fromSortedArray(hashComparator, wonkySet), SortedSet.fromSortedArray(hashComparator, punishSet));
8781
8145
  }
8782
8146
  }
8783
- function hashComparator(a, b) {
8784
- return a.compare(b);
8147
+ function hashComparator(a, b) {
8148
+ return a.compare(b);
8149
+ }
8150
+
8151
+ /** `O`: Maximum number of items in the authorizations pool. */
8152
+ const O = 8;
8153
+ /** `Q`: The number of items in the authorizations queue. */
8154
+ const Q = 80;
8155
+ /** `W_T`: The size of a transfer memo in octets. */
8156
+ const W_T = 128;
8157
+ /**
8158
+ * `J`: The maximum sum of dependency items in a work-report.
8159
+ *
8160
+ * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
8161
+ */
8162
+ const MAX_REPORT_DEPENDENCIES = 8;
8163
+ /** `Q`: Size of the authorization queue. */
8164
+ const AUTHORIZATION_QUEUE_SIZE = Q;
8165
+ /** `O`: Maximal authorization pool size. */
8166
+ const MAX_AUTH_POOL_SIZE = O;
8167
+
8168
+ const MAX_VALUE = 4294967295;
8169
+ const MIN_VALUE = -2147483648;
8170
+ const MAX_SHIFT_U32 = 32;
8171
+ const MAX_SHIFT_U64 = 64n;
8172
+
8173
+ /**
8174
+ * `B_S`: The basic minimum balance which all services require.
8175
+ *
8176
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
8177
+ */
8178
+ const BASE_SERVICE_BALANCE = 100n;
8179
+ /**
8180
+ * `B_I`: The additional minimum balance required per item of elective service state.
8181
+ *
8182
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
8183
+ */
8184
+ const ELECTIVE_ITEM_BALANCE = 10n;
8185
+ /**
8186
+ * `B_L`: The additional minimum balance required per octet of elective service state.
8187
+ *
8188
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
8189
+ */
8190
+ const ELECTIVE_BYTE_BALANCE = 1n;
8191
+ const zeroSizeHint = {
8192
+ bytes: 0,
8193
+ isExact: true,
8194
+ };
8195
+ /** 0-byte read, return given default value */
8196
+ const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
8197
+ /** Encode and decode object with leading version number. */
8198
+ const codecWithVersion = (val) => Descriptor.new("withVersion", {
8199
+ bytes: val.sizeHint.bytes + 8,
8200
+ isExact: false,
8201
+ }, (e, v) => {
8202
+ e.varU64(0n);
8203
+ val.encode(e, v);
8204
+ }, (d) => {
8205
+ const version = d.varU64();
8206
+ if (version !== 0n) {
8207
+ throw new Error("Non-zero version is not supported!");
8208
+ }
8209
+ return val.decode(d);
8210
+ }, (s) => {
8211
+ s.varU64();
8212
+ val.skip(s);
8213
+ });
8214
+ /**
8215
+ * Service account details.
8216
+ *
8217
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
8218
+ */
8219
+ class ServiceAccountInfo extends WithDebug {
8220
+ codeHash;
8221
+ balance;
8222
+ accumulateMinGas;
8223
+ onTransferMinGas;
8224
+ storageUtilisationBytes;
8225
+ gratisStorage;
8226
+ storageUtilisationCount;
8227
+ created;
8228
+ lastAccumulation;
8229
+ parentService;
8230
+ static Codec = codec$1.Class(ServiceAccountInfo, {
8231
+ codeHash: codec$1.bytes(HASH_SIZE).asOpaque(),
8232
+ balance: codec$1.u64,
8233
+ accumulateMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
8234
+ onTransferMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
8235
+ storageUtilisationBytes: codec$1.u64,
8236
+ gratisStorage: codec$1.u64,
8237
+ storageUtilisationCount: codec$1.u32,
8238
+ created: codec$1.u32.convert((x) => x, tryAsTimeSlot),
8239
+ lastAccumulation: codec$1.u32.convert((x) => x, tryAsTimeSlot),
8240
+ parentService: codec$1.u32.convert((x) => x, tryAsServiceId),
8241
+ });
8242
+ static create(a) {
8243
+ return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
8244
+ }
8245
+ /**
8246
+ * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
8247
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
8248
+ */
8249
+ static calculateThresholdBalance(items, bytes, gratisStorage) {
8250
+ const storageCost = BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
8251
+ if (storageCost < 0n) {
8252
+ return tryAsU64(0);
8253
+ }
8254
+ if (storageCost >= 2n ** 64n) {
8255
+ return tryAsU64(2n ** 64n - 1n);
8256
+ }
8257
+ return tryAsU64(storageCost);
8258
+ }
8259
+ constructor(
8260
+ /** `a_c`: Hash of the service code. */
8261
+ codeHash,
8262
+ /** `a_b`: Current account balance. */
8263
+ balance,
8264
+ /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
8265
+ accumulateMinGas,
8266
+ /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
8267
+ onTransferMinGas,
8268
+ /** `a_o`: Total number of octets in storage. */
8269
+ storageUtilisationBytes,
8270
+ /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
8271
+ gratisStorage,
8272
+ /** `a_i`: Number of items in storage. */
8273
+ storageUtilisationCount,
8274
+ /** `a_r`: Creation account time slot. */
8275
+ created,
8276
+ /** `a_a`: Most recent accumulation time slot. */
8277
+ lastAccumulation,
8278
+ /** `a_p`: Parent service ID. */
8279
+ parentService) {
8280
+ super();
8281
+ this.codeHash = codeHash;
8282
+ this.balance = balance;
8283
+ this.accumulateMinGas = accumulateMinGas;
8284
+ this.onTransferMinGas = onTransferMinGas;
8285
+ this.storageUtilisationBytes = storageUtilisationBytes;
8286
+ this.gratisStorage = gratisStorage;
8287
+ this.storageUtilisationCount = storageUtilisationCount;
8288
+ this.created = created;
8289
+ this.lastAccumulation = lastAccumulation;
8290
+ this.parentService = parentService;
8291
+ }
8292
+ }
8293
+ class PreimageItem extends WithDebug {
8294
+ hash;
8295
+ blob;
8296
+ static Codec = codec$1.Class(PreimageItem, {
8297
+ hash: codec$1.bytes(HASH_SIZE).asOpaque(),
8298
+ blob: codec$1.blob,
8299
+ });
8300
+ static create({ hash, blob }) {
8301
+ return new PreimageItem(hash, blob);
8302
+ }
8303
+ constructor(hash, blob) {
8304
+ super();
8305
+ this.hash = hash;
8306
+ this.blob = blob;
8307
+ }
8308
+ }
8309
+ class StorageItem extends WithDebug {
8310
+ key;
8311
+ value;
8312
+ static Codec = codec$1.Class(StorageItem, {
8313
+ key: codec$1.blob.convert((i) => i, (o) => asOpaqueType(o)),
8314
+ value: codec$1.blob,
8315
+ });
8316
+ static create({ key, value }) {
8317
+ return new StorageItem(key, value);
8318
+ }
8319
+ constructor(key, value) {
8320
+ super();
8321
+ this.key = key;
8322
+ this.value = value;
8323
+ }
8324
+ }
8325
+ const MAX_LOOKUP_HISTORY_SLOTS = 3;
8326
+ function tryAsLookupHistorySlots(items) {
8327
+ const knownSize = asKnownSize(items);
8328
+ if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
8329
+ throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
8330
+ }
8331
+ return knownSize;
8332
+ }
8333
+ /** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
8334
+ class LookupHistoryItem {
8335
+ hash;
8336
+ length;
8337
+ slots;
8338
+ constructor(hash, length,
8339
+ /**
8340
+ * Preimage availability history as a sequence of time slots.
8341
+ * See PreimageStatus and the following GP fragment for more details.
8342
+ * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
8343
+ slots) {
8344
+ this.hash = hash;
8345
+ this.length = length;
8346
+ this.slots = slots;
8347
+ }
8348
+ static isRequested(item) {
8349
+ if ("slots" in item) {
8350
+ return item.slots.length === 0;
8351
+ }
8352
+ return item.length === 0;
8353
+ }
8785
8354
  }
8786
8355
 
8787
- /** `O`: Maximum number of items in the authorizations pool. */
8788
- const O = 8;
8789
- /** `Q`: The number of items in the authorizations queue. */
8790
- const Q = 80;
8791
- /** `W_T`: The size of a transfer memo in octets. */
8792
- const W_T = 128;
8793
- // TODO [ToDr] Not sure where these should live yet :(
8794
- /**
8795
- * `J`: The maximum sum of dependency items in a work-report.
8796
- *
8797
- * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
8798
- */
8799
- const MAX_REPORT_DEPENDENCIES = 8;
8800
- /** `Q`: Size of the authorization queue. */
8801
- const AUTHORIZATION_QUEUE_SIZE = Q;
8802
- /** `O`: Maximal authorization pool size. */
8803
- const MAX_AUTH_POOL_SIZE = O;
8804
-
8805
8356
  /** Dictionary entry of services that auto-accumulate every block. */
8806
8357
  class AutoAccumulate {
8807
8358
  service;
@@ -8823,39 +8374,50 @@ class AutoAccumulate {
8823
8374
  }
8824
8375
  }
8825
8376
  /**
8826
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11da0111da01?v=0.6.7
8377
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
8827
8378
  */
8828
8379
  class PrivilegedServices {
8829
8380
  manager;
8830
- authManager;
8831
- validatorsManager;
8381
+ delegator;
8382
+ registrar;
8383
+ assigners;
8832
8384
  autoAccumulateServices;
8385
+ /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
8833
8386
  static Codec = codec$1.Class(PrivilegedServices, {
8834
8387
  manager: codec$1.u32.asOpaque(),
8835
- authManager: codecPerCore(codec$1.u32.asOpaque()),
8836
- validatorsManager: codec$1.u32.asOpaque(),
8388
+ assigners: codecPerCore(codec$1.u32.asOpaque()),
8389
+ delegator: codec$1.u32.asOpaque(),
8390
+ registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
8391
+ ? codec$1.u32.asOpaque()
8392
+ : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
8837
8393
  autoAccumulateServices: readonlyArray(codec$1.sequenceVarLen(AutoAccumulate.Codec)),
8838
8394
  });
8839
- static create({ manager, authManager, validatorsManager, autoAccumulateServices }) {
8840
- return new PrivilegedServices(manager, authManager, validatorsManager, autoAccumulateServices);
8395
+ static create(a) {
8396
+ return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
8841
8397
  }
8842
8398
  constructor(
8843
8399
  /**
8844
- * `chi_m`: The first, χm, is the index of the manager service which is
8845
- * the service able to effect an alteration of χ from block to block,
8400
+ * `χ_M`: Manages alteration of χ from block to block,
8846
8401
  * as well as bestow services with storage deposit credits.
8847
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/11a40111a801?v=0.6.7
8402
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
8848
8403
  */
8849
8404
  manager,
8850
- /** `chi_a`: Manages authorization queue one for each core. */
8851
- authManager,
8852
- /** `chi_v`: Managers validator keys. */
8853
- validatorsManager,
8854
- /** `chi_g`: Dictionary of services that auto-accumulate every block with their gas limit. */
8405
+ /** `χ_V`: Managers validator keys. */
8406
+ delegator,
8407
+ /**
8408
+ * `χ_R`: Manages the creation of services in protected range.
8409
+ *
8410
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
8411
+ */
8412
+ registrar,
8413
+ /** `χ_A`: Manages authorization queue one for each core. */
8414
+ assigners,
8415
+ /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
8855
8416
  autoAccumulateServices) {
8856
8417
  this.manager = manager;
8857
- this.authManager = authManager;
8858
- this.validatorsManager = validatorsManager;
8418
+ this.delegator = delegator;
8419
+ this.registrar = registrar;
8420
+ this.assigners = assigners;
8859
8421
  this.autoAccumulateServices = autoAccumulateServices;
8860
8422
  }
8861
8423
  }
@@ -9117,172 +8679,6 @@ class SafroleData {
9117
8679
  }
9118
8680
  }
9119
8681
 
9120
- /**
9121
- * `B_S`: The basic minimum balance which all services require.
9122
- *
9123
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
9124
- */
9125
- const BASE_SERVICE_BALANCE = 100n;
9126
- /**
9127
- * `B_I`: The additional minimum balance required per item of elective service state.
9128
- *
9129
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
9130
- */
9131
- const ELECTIVE_ITEM_BALANCE = 10n;
9132
- /**
9133
- * `B_L`: The additional minimum balance required per octet of elective service state.
9134
- *
9135
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
9136
- */
9137
- const ELECTIVE_BYTE_BALANCE = 1n;
9138
- const zeroSizeHint = {
9139
- bytes: 0,
9140
- isExact: true,
9141
- };
9142
- /** 0-byte read, return given default value */
9143
- const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
9144
- /**
9145
- * Service account details.
9146
- *
9147
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
9148
- */
9149
- class ServiceAccountInfo extends WithDebug {
9150
- codeHash;
9151
- balance;
9152
- accumulateMinGas;
9153
- onTransferMinGas;
9154
- storageUtilisationBytes;
9155
- gratisStorage;
9156
- storageUtilisationCount;
9157
- created;
9158
- lastAccumulation;
9159
- parentService;
9160
- static Codec = codec$1.Class(ServiceAccountInfo, {
9161
- codeHash: codec$1.bytes(HASH_SIZE).asOpaque(),
9162
- balance: codec$1.u64,
9163
- accumulateMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
9164
- onTransferMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
9165
- storageUtilisationBytes: codec$1.u64,
9166
- gratisStorage: codec$1.u64,
9167
- storageUtilisationCount: codec$1.u32,
9168
- created: codec$1.u32.convert((x) => x, tryAsTimeSlot),
9169
- lastAccumulation: codec$1.u32.convert((x) => x, tryAsTimeSlot),
9170
- parentService: codec$1.u32.convert((x) => x, tryAsServiceId),
9171
- });
9172
- static create(a) {
9173
- return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
9174
- }
9175
- /**
9176
- * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
9177
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
9178
- */
9179
- static calculateThresholdBalance(items, bytes, gratisStorage) {
9180
- const storageCost = BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
9181
- if (storageCost < 0n) {
9182
- return tryAsU64(0);
9183
- }
9184
- if (storageCost >= 2n ** 64n) {
9185
- return tryAsU64(2n ** 64n - 1n);
9186
- }
9187
- return tryAsU64(storageCost);
9188
- }
9189
- constructor(
9190
- /** `a_c`: Hash of the service code. */
9191
- codeHash,
9192
- /** `a_b`: Current account balance. */
9193
- balance,
9194
- /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
9195
- accumulateMinGas,
9196
- /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
9197
- onTransferMinGas,
9198
- /** `a_o`: Total number of octets in storage. */
9199
- storageUtilisationBytes,
9200
- /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
9201
- gratisStorage,
9202
- /** `a_i`: Number of items in storage. */
9203
- storageUtilisationCount,
9204
- /** `a_r`: Creation account time slot. */
9205
- created,
9206
- /** `a_a`: Most recent accumulation time slot. */
9207
- lastAccumulation,
9208
- /** `a_p`: Parent service ID. */
9209
- parentService) {
9210
- super();
9211
- this.codeHash = codeHash;
9212
- this.balance = balance;
9213
- this.accumulateMinGas = accumulateMinGas;
9214
- this.onTransferMinGas = onTransferMinGas;
9215
- this.storageUtilisationBytes = storageUtilisationBytes;
9216
- this.gratisStorage = gratisStorage;
9217
- this.storageUtilisationCount = storageUtilisationCount;
9218
- this.created = created;
9219
- this.lastAccumulation = lastAccumulation;
9220
- this.parentService = parentService;
9221
- }
9222
- }
9223
- class PreimageItem extends WithDebug {
9224
- hash;
9225
- blob;
9226
- static Codec = codec$1.Class(PreimageItem, {
9227
- hash: codec$1.bytes(HASH_SIZE).asOpaque(),
9228
- blob: codec$1.blob,
9229
- });
9230
- static create({ hash, blob }) {
9231
- return new PreimageItem(hash, blob);
9232
- }
9233
- constructor(hash, blob) {
9234
- super();
9235
- this.hash = hash;
9236
- this.blob = blob;
9237
- }
9238
- }
9239
- class StorageItem extends WithDebug {
9240
- key;
9241
- value;
9242
- static Codec = codec$1.Class(StorageItem, {
9243
- key: codec$1.blob.convert((i) => i, (o) => asOpaqueType(o)),
9244
- value: codec$1.blob,
9245
- });
9246
- static create({ key, value }) {
9247
- return new StorageItem(key, value);
9248
- }
9249
- constructor(key, value) {
9250
- super();
9251
- this.key = key;
9252
- this.value = value;
9253
- }
9254
- }
9255
- const MAX_LOOKUP_HISTORY_SLOTS = 3;
9256
- function tryAsLookupHistorySlots(items) {
9257
- const knownSize = asKnownSize(items);
9258
- if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
9259
- throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
9260
- }
9261
- return knownSize;
9262
- }
9263
- /** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
9264
- class LookupHistoryItem {
9265
- hash;
9266
- length;
9267
- slots;
9268
- constructor(hash, length,
9269
- /**
9270
- * Preimage availability history as a sequence of time slots.
9271
- * See PreimageStatus and the following GP fragment for more details.
9272
- * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
9273
- slots) {
9274
- this.hash = hash;
9275
- this.length = length;
9276
- this.slots = slots;
9277
- }
9278
- static isRequested(item) {
9279
- if ("slots" in item) {
9280
- return item.slots.length === 0;
9281
- }
9282
- return item.length === 0;
9283
- }
9284
- }
9285
-
9286
8682
  /**
9287
8683
  * In addition to the entropy accumulator η_0, we retain
9288
8684
  * three additional historical values of the accumulator at
@@ -10090,8 +9486,9 @@ class InMemoryState extends WithDebug {
10090
9486
  epochRoot: Bytes.zero(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
10091
9487
  privilegedServices: PrivilegedServices.create({
10092
9488
  manager: tryAsServiceId(0),
10093
- authManager: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
10094
- validatorsManager: tryAsServiceId(0),
9489
+ assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
9490
+ delegator: tryAsServiceId(0),
9491
+ registrar: tryAsServiceId(MAX_VALUE),
10095
9492
  autoAccumulateServices: [],
10096
9493
  }),
10097
9494
  accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
@@ -10150,6 +9547,7 @@ var index$g = /*#__PURE__*/Object.freeze({
10150
9547
  ValidatorStatistics: ValidatorStatistics,
10151
9548
  accumulationOutputComparator: accumulationOutputComparator,
10152
9549
  codecPerCore: codecPerCore,
9550
+ codecWithVersion: codecWithVersion,
10153
9551
  hashComparator: hashComparator,
10154
9552
  ignoreValueWithDefault: ignoreValueWithDefault,
10155
9553
  serviceDataCodec: serviceDataCodec,
@@ -10310,21 +9708,23 @@ var serialize;
10310
9708
  /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
10311
9709
  serialize.serviceData = (serviceId) => ({
10312
9710
  key: stateKeys.serviceInfo(serviceId),
10313
- Codec: ServiceAccountInfo.Codec,
9711
+ Codec: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
9712
+ ? codecWithVersion(ServiceAccountInfo.Codec)
9713
+ : ServiceAccountInfo.Codec,
10314
9714
  });
10315
9715
  /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
10316
- serialize.serviceStorage = (serviceId, key) => ({
10317
- key: stateKeys.serviceStorage(serviceId, key),
9716
+ serialize.serviceStorage = (blake2b, serviceId, key) => ({
9717
+ key: stateKeys.serviceStorage(blake2b, serviceId, key),
10318
9718
  Codec: dumpCodec,
10319
9719
  });
10320
9720
  /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
10321
- serialize.servicePreimages = (serviceId, hash) => ({
10322
- key: stateKeys.servicePreimage(serviceId, hash),
9721
+ serialize.servicePreimages = (blake2b, serviceId, hash) => ({
9722
+ key: stateKeys.servicePreimage(blake2b, serviceId, hash),
10323
9723
  Codec: dumpCodec,
10324
9724
  });
10325
9725
  /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
10326
- serialize.serviceLookupHistory = (serviceId, hash, len) => ({
10327
- key: stateKeys.serviceLookupHistory(serviceId, hash, len),
9726
+ serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
9727
+ key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
10328
9728
  Codec: readonlyArray(codec$1.sequenceVarLen(codec$1.u32)),
10329
9729
  });
10330
9730
  })(serialize || (serialize = {}));
@@ -10347,20 +9747,22 @@ const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) =
10347
9747
  */
10348
9748
  class SerializedState {
10349
9749
  spec;
9750
+ blake2b;
10350
9751
  backend;
10351
9752
  _recentServiceIds;
10352
9753
  /** Create a state-like object from collection of serialized entries. */
10353
- static fromStateEntries(spec, state, recentServices = []) {
10354
- return new SerializedState(spec, state, recentServices);
9754
+ static fromStateEntries(spec, blake2b, state, recentServices = []) {
9755
+ return new SerializedState(spec, blake2b, state, recentServices);
10355
9756
  }
10356
9757
  /** Create a state-like object backed by some DB. */
10357
- static new(spec, db, recentServices = []) {
10358
- return new SerializedState(spec, db, recentServices);
9758
+ static new(spec, blake2b, db, recentServices = []) {
9759
+ return new SerializedState(spec, blake2b, db, recentServices);
10359
9760
  }
10360
- constructor(spec, backend,
9761
+ constructor(spec, blake2b, backend,
10361
9762
  /** Best-effort list of recently active services. */
10362
9763
  _recentServiceIds) {
10363
9764
  this.spec = spec;
9765
+ this.blake2b = blake2b;
10364
9766
  this.backend = backend;
10365
9767
  this._recentServiceIds = _recentServiceIds;
10366
9768
  }
@@ -10384,7 +9786,7 @@ class SerializedState {
10384
9786
  if (!this._recentServiceIds.includes(id)) {
10385
9787
  this._recentServiceIds.push(id);
10386
9788
  }
10387
- return new SerializedService(id, serviceData, (key) => this.retrieveOptional(key));
9789
+ return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
10388
9790
  }
10389
9791
  retrieve({ key, Codec }, description) {
10390
9792
  const bytes = this.backend.get(key);
@@ -10460,12 +9862,14 @@ class SerializedState {
10460
9862
  }
10461
9863
  /** Service data representation on a serialized state. */
10462
9864
  class SerializedService {
9865
+ blake2b;
10463
9866
  serviceId;
10464
9867
  accountInfo;
10465
9868
  retrieveOptional;
10466
- constructor(
9869
+ constructor(blake2b,
10467
9870
  /** Service id */
10468
9871
  serviceId, accountInfo, retrieveOptional) {
9872
+ this.blake2b = blake2b;
10469
9873
  this.serviceId = serviceId;
10470
9874
  this.accountInfo = accountInfo;
10471
9875
  this.retrieveOptional = retrieveOptional;
@@ -10481,10 +9885,10 @@ class SerializedService {
10481
9885
  const serviceIdAndKey = safeAllocUint8Array(SERVICE_ID_BYTES + rawKey.length);
10482
9886
  serviceIdAndKey.set(u32AsLeBytes(this.serviceId));
10483
9887
  serviceIdAndKey.set(rawKey.raw, SERVICE_ID_BYTES);
10484
- const key = asOpaqueType(BytesBlob.blobFrom(hashBytes(serviceIdAndKey).raw));
10485
- return this.retrieveOptional(serialize.serviceStorage(this.serviceId, key)) ?? null;
9888
+ const key = asOpaqueType(BytesBlob.blobFrom(this.blake2b.hashBytes(serviceIdAndKey).raw));
9889
+ return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, key)) ?? null;
10486
9890
  }
10487
- return this.retrieveOptional(serialize.serviceStorage(this.serviceId, rawKey)) ?? null;
9891
+ return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, rawKey)) ?? null;
10488
9892
  }
10489
9893
  /**
10490
9894
  * Check if preimage is present in the DB.
@@ -10493,15 +9897,15 @@ class SerializedService {
10493
9897
  */
10494
9898
  hasPreimage(hash) {
10495
9899
  // TODO [ToDr] consider optimizing to avoid fetching the whole data.
10496
- return this.retrieveOptional(serialize.servicePreimages(this.serviceId, hash)) !== undefined;
9900
+ return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) !== undefined;
10497
9901
  }
10498
9902
  /** Retrieve preimage from the DB. */
10499
9903
  getPreimage(hash) {
10500
- return this.retrieveOptional(serialize.servicePreimages(this.serviceId, hash)) ?? null;
9904
+ return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) ?? null;
10501
9905
  }
10502
9906
  /** Retrieve preimage lookup history. */
10503
9907
  getLookupHistory(hash, len) {
10504
- const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.serviceId, hash, len));
9908
+ const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.blake2b, this.serviceId, hash, len));
10505
9909
  if (rawSlots === undefined) {
10506
9910
  return null;
10507
9911
  }
@@ -11138,11 +10542,13 @@ var index$f = /*#__PURE__*/Object.freeze({
11138
10542
  parseInputKey: parseInputKey
11139
10543
  });
11140
10544
 
11141
- const blake2bTrieHasher = {
11142
- hashConcat(n, rest = []) {
11143
- return hashBlobs$1([n, ...rest]);
11144
- },
11145
- };
10545
+ function getBlake2bTrieHasher(hasher) {
10546
+ return {
10547
+ hashConcat(n, rest = []) {
10548
+ return hasher.hashBlobs([n, ...rest]);
10549
+ },
10550
+ };
10551
+ }
11146
10552
 
11147
10553
  /** What should be done with that key? */
11148
10554
  var StateEntryUpdateAction;
@@ -11154,14 +10560,14 @@ var StateEntryUpdateAction;
11154
10560
  })(StateEntryUpdateAction || (StateEntryUpdateAction = {}));
11155
10561
  const EMPTY_BLOB = BytesBlob.empty();
11156
10562
  /** Serialize given state update into a series of key-value pairs. */
11157
- function* serializeStateUpdate(spec, update) {
10563
+ function* serializeStateUpdate(spec, blake2b, update) {
11158
10564
  // first let's serialize all of the simple entries (if present!)
11159
10565
  yield* serializeBasicKeys(spec, update);
11160
10566
  const encode = (codec, val) => Encoder.encodeObject(codec, val, spec);
11161
10567
  // then let's proceed with service updates
11162
- yield* serializeServiceUpdates(update.servicesUpdates, encode);
11163
- yield* serializePreimages(update.preimages, encode);
11164
- yield* serializeStorage(update.storage);
10568
+ yield* serializeServiceUpdates(update.servicesUpdates, encode, blake2b);
10569
+ yield* serializePreimages(update.preimages, encode, blake2b);
10570
+ yield* serializeStorage(update.storage, blake2b);
11165
10571
  yield* serializeRemovedServices(update.servicesRemoved);
11166
10572
  }
11167
10573
  function* serializeRemovedServices(servicesRemoved) {
@@ -11171,18 +10577,18 @@ function* serializeRemovedServices(servicesRemoved) {
11171
10577
  yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
11172
10578
  }
11173
10579
  }
11174
- function* serializeStorage(storage) {
10580
+ function* serializeStorage(storage, blake2b) {
11175
10581
  for (const { action, serviceId } of storage ?? []) {
11176
10582
  switch (action.kind) {
11177
10583
  case UpdateStorageKind.Set: {
11178
10584
  const key = action.storage.key;
11179
- const codec = serialize.serviceStorage(serviceId, key);
10585
+ const codec = serialize.serviceStorage(blake2b, serviceId, key);
11180
10586
  yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
11181
10587
  break;
11182
10588
  }
11183
10589
  case UpdateStorageKind.Remove: {
11184
10590
  const key = action.key;
11185
- const codec = serialize.serviceStorage(serviceId, key);
10591
+ const codec = serialize.serviceStorage(blake2b, serviceId, key);
11186
10592
  yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
11187
10593
  break;
11188
10594
  }
@@ -11191,15 +10597,15 @@ function* serializeStorage(storage) {
11191
10597
  }
11192
10598
  }
11193
10599
  }
11194
- function* serializePreimages(preimages, encode) {
10600
+ function* serializePreimages(preimages, encode, blake2b) {
11195
10601
  for (const { action, serviceId } of preimages ?? []) {
11196
10602
  switch (action.kind) {
11197
10603
  case UpdatePreimageKind.Provide: {
11198
10604
  const { hash, blob } = action.preimage;
11199
- const codec = serialize.servicePreimages(serviceId, hash);
10605
+ const codec = serialize.servicePreimages(blake2b, serviceId, hash);
11200
10606
  yield [StateEntryUpdateAction.Insert, codec.key, blob];
11201
10607
  if (action.slot !== null) {
11202
- const codec2 = serialize.serviceLookupHistory(serviceId, hash, tryAsU32(blob.length));
10608
+ const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, tryAsU32(blob.length));
11203
10609
  yield [
11204
10610
  StateEntryUpdateAction.Insert,
11205
10611
  codec2.key,
@@ -11210,15 +10616,15 @@ function* serializePreimages(preimages, encode) {
11210
10616
  }
11211
10617
  case UpdatePreimageKind.UpdateOrAdd: {
11212
10618
  const { hash, length, slots } = action.item;
11213
- const codec = serialize.serviceLookupHistory(serviceId, hash, length);
10619
+ const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
11214
10620
  yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
11215
10621
  break;
11216
10622
  }
11217
10623
  case UpdatePreimageKind.Remove: {
11218
10624
  const { hash, length } = action;
11219
- const codec = serialize.servicePreimages(serviceId, hash);
10625
+ const codec = serialize.servicePreimages(blake2b, serviceId, hash);
11220
10626
  yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
11221
- const codec2 = serialize.serviceLookupHistory(serviceId, hash, length);
10627
+ const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
11222
10628
  yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
11223
10629
  break;
11224
10630
  }
@@ -11227,7 +10633,7 @@ function* serializePreimages(preimages, encode) {
11227
10633
  }
11228
10634
  }
11229
10635
  }
11230
- function* serializeServiceUpdates(servicesUpdates, encode) {
10636
+ function* serializeServiceUpdates(servicesUpdates, encode, blake2b) {
11231
10637
  for (const { action, serviceId } of servicesUpdates ?? []) {
11232
10638
  // new service being created or updated
11233
10639
  const codec = serialize.serviceData(serviceId);
@@ -11235,7 +10641,7 @@ function* serializeServiceUpdates(servicesUpdates, encode) {
11235
10641
  // additional lookup history update
11236
10642
  if (action.kind === UpdateServiceKind.Create && action.lookupHistory !== null) {
11237
10643
  const { lookupHistory } = action;
11238
- const codec2 = serialize.serviceLookupHistory(serviceId, lookupHistory.hash, lookupHistory.length);
10644
+ const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
11239
10645
  yield [StateEntryUpdateAction.Insert, codec2.key, encode(codec2.Codec, lookupHistory.slots)];
11240
10646
  }
11241
10647
  }
@@ -11330,8 +10736,8 @@ class StateEntries {
11330
10736
  },
11331
10737
  }, (e, v) => stateEntriesSequenceCodec.encode(e, Array.from(v.entries)), (d) => StateEntries.fromEntriesUnsafe(stateEntriesSequenceCodec.decode(d)), (s) => stateEntriesSequenceCodec.skip(s));
11332
10738
  /** Turn in-memory state into it's serialized form. */
11333
- static serializeInMemory(spec, state) {
11334
- return new StateEntries(convertInMemoryStateToDictionary(spec, state));
10739
+ static serializeInMemory(spec, blake2b, state) {
10740
+ return new StateEntries(convertInMemoryStateToDictionary(spec, blake2b, state));
11335
10741
  }
11336
10742
  /**
11337
10743
  * Wrap a collection of truncated state entries and treat it as state.
@@ -11380,7 +10786,8 @@ class StateEntries {
11380
10786
  }
11381
10787
  }
11382
10788
  /** https://graypaper.fluffylabs.dev/#/68eaa1f/391600391600?v=0.6.4 */
11383
- getRootHash() {
10789
+ getRootHash(blake2b) {
10790
+ const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
11384
10791
  const leaves = SortedSet.fromArray(leafComparator);
11385
10792
  for (const [key, value] of this) {
11386
10793
  leaves.insert(InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value));
@@ -11389,7 +10796,7 @@ class StateEntries {
11389
10796
  }
11390
10797
  }
11391
10798
  /** https://graypaper.fluffylabs.dev/#/68eaa1f/38a50038a500?v=0.6.4 */
11392
- function convertInMemoryStateToDictionary(spec, state) {
10799
+ function convertInMemoryStateToDictionary(spec, blake2b, state) {
11393
10800
  const serialized = TruncatedHashDictionary.fromEntries([]);
11394
10801
  function doSerialize(codec) {
11395
10802
  serialized.set(codec.key, Encoder.encodeObject(codec.Codec, codec.extract(state), spec));
@@ -11417,18 +10824,18 @@ function convertInMemoryStateToDictionary(spec, state) {
11417
10824
  serialized.set(key, Encoder.encodeObject(Codec, service.getInfo()));
11418
10825
  // preimages
11419
10826
  for (const preimage of service.data.preimages.values()) {
11420
- const { key, Codec } = serialize.servicePreimages(serviceId, preimage.hash);
10827
+ const { key, Codec } = serialize.servicePreimages(blake2b, serviceId, preimage.hash);
11421
10828
  serialized.set(key, Encoder.encodeObject(Codec, preimage.blob));
11422
10829
  }
11423
10830
  // storage
11424
10831
  for (const storage of service.data.storage.values()) {
11425
- const { key, Codec } = serialize.serviceStorage(serviceId, storage.key);
10832
+ const { key, Codec } = serialize.serviceStorage(blake2b, serviceId, storage.key);
11426
10833
  serialized.set(key, Encoder.encodeObject(Codec, storage.value));
11427
10834
  }
11428
10835
  // lookup history
11429
10836
  for (const lookupHistoryList of service.data.lookupHistory.values()) {
11430
10837
  for (const lookupHistory of lookupHistoryList) {
11431
- const { key, Codec } = serialize.serviceLookupHistory(serviceId, lookupHistory.hash, lookupHistory.length);
10838
+ const { key, Codec } = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
11432
10839
  serialized.set(key, Encoder.encodeObject(Codec, lookupHistory.slots.slice()));
11433
10840
  }
11434
10841
  }
@@ -11436,9 +10843,9 @@ function convertInMemoryStateToDictionary(spec, state) {
11436
10843
  return serialized;
11437
10844
  }
11438
10845
 
11439
- function loadState(spec, entries) {
10846
+ function loadState(spec, blake2b, entries) {
11440
10847
  const stateEntries = StateEntries.fromEntriesUnsafe(entries);
11441
- return SerializedState.fromStateEntries(spec, stateEntries);
10848
+ return SerializedState.fromStateEntries(spec, blake2b, stateEntries);
11442
10849
  }
11443
10850
 
11444
10851
  /**
@@ -11546,7 +10953,8 @@ class LeafDb {
11546
10953
  }
11547
10954
  assertNever(val);
11548
10955
  }
11549
- getStateRoot() {
10956
+ getStateRoot(blake2b) {
10957
+ const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
11550
10958
  return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leaves).asOpaque();
11551
10959
  }
11552
10960
  intoStateEntries() {
@@ -11736,7 +11144,8 @@ class InMemoryStates {
11736
11144
  }
11737
11145
  }
11738
11146
  async getStateRoot(state) {
11739
- return StateEntries.serializeInMemory(this.spec, state).getRootHash();
11147
+ const blake2b = await Blake2b.createHasher();
11148
+ return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
11740
11149
  }
11741
11150
  /** Insert a full state into the database. */
11742
11151
  async insertState(headerHash, state) {
@@ -12686,6 +12095,8 @@ var NewServiceError;
12686
12095
  NewServiceError[NewServiceError["InsufficientFunds"] = 0] = "InsufficientFunds";
12687
12096
  /** Service is not privileged to set gratis storage. */
12688
12097
  NewServiceError[NewServiceError["UnprivilegedService"] = 1] = "UnprivilegedService";
12098
+ /** Registrar attempting to create a service with already existing id. */
12099
+ NewServiceError[NewServiceError["RegistrarServiceIdAlreadyTaken"] = 2] = "RegistrarServiceIdAlreadyTaken";
12689
12100
  })(NewServiceError || (NewServiceError = {}));
12690
12101
  var UpdatePrivilegesError;
12691
12102
  (function (UpdatePrivilegesError) {
@@ -12876,7 +12287,7 @@ class AccumulationStateUpdate {
12876
12287
  if (from.privilegedServices !== null) {
12877
12288
  update.privilegedServices = PrivilegedServices.create({
12878
12289
  ...from.privilegedServices,
12879
- authManager: asKnownSize([...from.privilegedServices.authManager]),
12290
+ assigners: asKnownSize([...from.privilegedServices.assigners]),
12880
12291
  });
12881
12292
  }
12882
12293
  return update;
@@ -13077,7 +12488,7 @@ const HostCallResult = {
13077
12488
  OOB: tryAsU64(0xfffffffffffffffdn), // 2**64 - 3
13078
12489
  /** Index unknown. */
13079
12490
  WHO: tryAsU64(0xfffffffffffffffcn), // 2**64 - 4
13080
- /** Storage full. */
12491
+ /** Storage full or resource already allocated. */
13081
12492
  FULL: tryAsU64(0xfffffffffffffffbn), // 2**64 - 5
13082
12493
  /** Core index unknown. */
13083
12494
  CORE: tryAsU64(0xfffffffffffffffan), // 2**64 - 6
@@ -13085,7 +12496,7 @@ const HostCallResult = {
13085
12496
  CASH: tryAsU64(0xfffffffffffffff9n), // 2**64 - 7
13086
12497
  /** Gas limit too low. */
13087
12498
  LOW: tryAsU64(0xfffffffffffffff8n), // 2**64 - 8
13088
- /** The item is already solicited or cannot be forgotten. */
12499
+ /** The item is already solicited, cannot be forgotten or the operation is invalid due to privilege level. */
13089
12500
  HUH: tryAsU64(0xfffffffffffffff7n), // 2**64 - 9
13090
12501
  /** The return value indicating general success. */
13091
12502
  OK: tryAsU64(0n),
@@ -15120,11 +14531,6 @@ class BitOps {
15120
14531
  }
15121
14532
  }
15122
14533
 
15123
- const MAX_VALUE = 4294967295;
15124
- const MIN_VALUE = -2147483648;
15125
- const MAX_SHIFT_U32 = 32;
15126
- const MAX_SHIFT_U64 = 64n;
15127
-
15128
14534
  /**
15129
14535
  * Overflowing addition for two-complement representation of 32-bit signed numbers.
15130
14536
  */
@@ -17434,7 +16840,7 @@ var index$3 = /*#__PURE__*/Object.freeze({
17434
16840
  extractCodeAndMetadata: extractCodeAndMetadata,
17435
16841
  getServiceId: getServiceId,
17436
16842
  getServiceIdOrCurrent: getServiceIdOrCurrent,
17437
- hash: index$p,
16843
+ hash: index$o,
17438
16844
  inspect: inspect,
17439
16845
  instructionArgumentTypeMap: instructionArgumentTypeMap,
17440
16846
  interpreter: index$7,
@@ -17456,10 +16862,10 @@ const ENTROPY_BYTES = 32;
17456
16862
  *
17457
16863
  * https://graypaper.fluffylabs.dev/#/579bd12/3b9a013b9a01
17458
16864
  */
17459
- function fisherYatesShuffle(arr, entropy) {
16865
+ function fisherYatesShuffle(blake2b, arr, entropy) {
17460
16866
  check `${entropy.length === ENTROPY_BYTES} Expected entropy of length ${ENTROPY_BYTES}, got ${entropy.length}`;
17461
16867
  const n = arr.length;
17462
- const randomNumbers = hashToNumberSequence(entropy, arr.length);
16868
+ const randomNumbers = hashToNumberSequence(blake2b, entropy, arr.length);
17463
16869
  const result = new Array(n);
17464
16870
  let itemsLeft = n;
17465
16871
  for (let i = 0; i < n; i++) {
@@ -17472,13 +16878,13 @@ function fisherYatesShuffle(arr, entropy) {
17472
16878
  }
17473
16879
  return result;
17474
16880
  }
17475
- function hashToNumberSequence(entropy, length) {
16881
+ function hashToNumberSequence(blake2b, entropy, length) {
17476
16882
  const result = new Array(length);
17477
16883
  const randomBytes = safeAllocUint8Array(ENTROPY_BYTES + 4);
17478
16884
  randomBytes.set(entropy.raw);
17479
16885
  for (let i = 0; i < length; i++) {
17480
16886
  randomBytes.set(u32AsLeBytes(tryAsU32(Math.floor(i / 8))), ENTROPY_BYTES);
17481
- const newHash = hashBytes(randomBytes);
16887
+ const newHash = blake2b.hashBytes(randomBytes);
17482
16888
  const numberStartIndex = (4 * i) % 32;
17483
16889
  const numberEndIndex = numberStartIndex + 4;
17484
16890
  const number = leBytesAsU32(newHash.raw.subarray(numberStartIndex, numberEndIndex)) >>> 0;
@@ -17592,8 +16998,7 @@ const availabilityAssignmentFromJson = json.object({
17592
16998
  report: workReportFromJson,
17593
16999
  timeout: "number",
17594
17000
  }, ({ report, timeout }) => {
17595
- const workReportHash = hashBytes(Encoder.encodeObject(WorkReport.Codec, report)).asOpaque();
17596
- return AvailabilityAssignment.create({ workReport: new WithHash(workReportHash, report), timeout });
17001
+ return AvailabilityAssignment.create({ workReport: report, timeout });
17597
17002
  });
17598
17003
 
17599
17004
  const disputesRecordsFromJson = json.object({
@@ -17827,6 +17232,7 @@ const fullStateDumpFromJson = (spec) => json.object({
17827
17232
  chi_m: "number",
17828
17233
  chi_a: json.array("number"),
17829
17234
  chi_v: "number",
17235
+ chi_r: json.optional("number"),
17830
17236
  chi_g: json.nullable(json.array({
17831
17237
  service: "number",
17832
17238
  gasLimit: json.fromNumber((v) => tryAsServiceGas(v)),
@@ -17838,6 +17244,9 @@ const fullStateDumpFromJson = (spec) => json.object({
17838
17244
  theta: json.nullable(json.array(accumulationOutput)),
17839
17245
  accounts: json.array(JsonService.fromJson),
17840
17246
  }, ({ alpha, varphi, beta, gamma, psi, eta, iota, kappa, lambda, rho, tau, chi, pi, omega, xi, theta, accounts, }) => {
17247
+ if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) && chi.chi_r === undefined) {
17248
+ throw new Error("Registrar is required in Privileges GP ^0.7.1");
17249
+ }
17841
17250
  return InMemoryState.create({
17842
17251
  authPools: tryAsPerCore(alpha.map((perCore) => {
17843
17252
  if (perCore.length > MAX_AUTH_POOL_SIZE) {
@@ -17865,8 +17274,9 @@ const fullStateDumpFromJson = (spec) => json.object({
17865
17274
  timeslot: tau,
17866
17275
  privilegedServices: PrivilegedServices.create({
17867
17276
  manager: chi.chi_m,
17868
- authManager: chi.chi_a,
17869
- validatorsManager: chi.chi_v,
17277
+ assigners: chi.chi_a,
17278
+ delegator: chi.chi_v,
17279
+ registrar: chi.chi_r ?? tryAsServiceId(2 ** 32 - 1),
17870
17280
  autoAccumulateServices: chi.chi_g ?? [],
17871
17281
  }),
17872
17282
  statistics: JsonStatisticsData.toStatisticsData(spec, pi),
@@ -17899,11 +17309,11 @@ var index$1 = /*#__PURE__*/Object.freeze({
17899
17309
  class TransitionHasher {
17900
17310
  context;
17901
17311
  keccakHasher;
17902
- allocator;
17903
- constructor(context, keccakHasher, allocator) {
17312
+ blake2b;
17313
+ constructor(context, keccakHasher, blake2b) {
17904
17314
  this.context = context;
17905
17315
  this.keccakHasher = keccakHasher;
17906
- this.allocator = allocator;
17316
+ this.blake2b = blake2b;
17907
17317
  }
17908
17318
  /** Concatenates two hashes and hash this concatenation */
17909
17319
  hashConcat(a, b) {
@@ -17914,7 +17324,7 @@ class TransitionHasher {
17914
17324
  }
17915
17325
  /** Creates hash from the block header view */
17916
17326
  header(header) {
17917
- return new WithHash(hashBytes(header.encoded(), this.allocator).asOpaque(), header);
17327
+ return new WithHash(this.blake2b.hashBytes(header.encoded()).asOpaque(), header);
17918
17328
  }
17919
17329
  /**
17920
17330
  * Merkle commitment of the extrinsic data
@@ -17927,7 +17337,7 @@ class TransitionHasher {
17927
17337
  .view()
17928
17338
  .map((g) => g.view())
17929
17339
  .map((guarantee) => {
17930
- const reportHash = hashBytes(guarantee.report.encoded(), this.allocator).asOpaque();
17340
+ const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque();
17931
17341
  return BytesBlob.blobFromParts([
17932
17342
  reportHash.raw,
17933
17343
  guarantee.slot.encoded().raw,
@@ -17935,13 +17345,13 @@ class TransitionHasher {
17935
17345
  ]);
17936
17346
  });
17937
17347
  const guaranteeBlob = Encoder.encodeObject(codec$1.sequenceVarLen(dumpCodec), guarantees, this.context);
17938
- const et = hashBytes(extrinsicView.tickets.encoded(), this.allocator).asOpaque();
17939
- const ep = hashBytes(extrinsicView.preimages.encoded(), this.allocator).asOpaque();
17940
- const eg = hashBytes(guaranteeBlob, this.allocator).asOpaque();
17941
- const ea = hashBytes(extrinsicView.assurances.encoded(), this.allocator).asOpaque();
17942
- const ed = hashBytes(extrinsicView.disputes.encoded(), this.allocator).asOpaque();
17348
+ const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque();
17349
+ const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque();
17350
+ const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque();
17351
+ const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque();
17352
+ const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque();
17943
17353
  const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
17944
- return new WithHashAndBytes(hashBytes(encoded, this.allocator).asOpaque(), extrinsicView, encoded);
17354
+ return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), extrinsicView, encoded);
17945
17355
  }
17946
17356
  /** Creates hash for given WorkPackage */
17947
17357
  workPackage(workPackage) {
@@ -17950,7 +17360,7 @@ class TransitionHasher {
17950
17360
  encode(codec, data) {
17951
17361
  // TODO [ToDr] Use already allocated encoding destination and hash bytes from some arena.
17952
17362
  const encoded = Encoder.encodeObject(codec, data, this.context);
17953
- return new WithHashAndBytes(hashBytes(encoded, this.allocator).asOpaque(), data, encoded);
17363
+ return new WithHashAndBytes(this.blake2b.hashBytes(encoded).asOpaque(), data, encoded);
17954
17364
  }
17955
17365
  }
17956
17366
 
@@ -17963,8 +17373,10 @@ var PreimagesErrorCode;
17963
17373
  // TODO [SeKo] consider whether this module is the right place to remove expired preimages
17964
17374
  class Preimages {
17965
17375
  state;
17966
- constructor(state) {
17376
+ blake2b;
17377
+ constructor(state, blake2b) {
17967
17378
  this.state = state;
17379
+ this.blake2b = blake2b;
17968
17380
  }
17969
17381
  integrate(input) {
17970
17382
  // make sure lookup extrinsics are sorted and unique
@@ -17987,7 +17399,7 @@ class Preimages {
17987
17399
  // select preimages for integration
17988
17400
  for (const preimage of preimages) {
17989
17401
  const { requester, blob } = preimage;
17990
- const hash = hashBytes(blob).asOpaque();
17402
+ const hash = this.blake2b.hashBytes(blob).asOpaque();
17991
17403
  const service = this.state.getService(requester);
17992
17404
  if (service === null) {
17993
17405
  return Result$1.error(PreimagesErrorCode.AccountNotFound);
@@ -18012,146 +17424,11 @@ class Preimages {
18012
17424
  }
18013
17425
  }
18014
17426
 
18015
- class Missing {
18016
- index = tryAsHostCallIndex(2 ** 32 - 1);
18017
- basicGasCost = tryAsSmallGas(10);
18018
- currentServiceId = CURRENT_SERVICE_ID;
18019
- tracedRegisters = traceRegisters(7);
18020
- execute(_gas, regs, _memory) {
18021
- regs.set(7, HostCallResult.WHAT);
18022
- return Promise.resolve(undefined);
18023
- }
18024
- }
18025
-
18026
- var ServiceExecutorError;
18027
- (function (ServiceExecutorError) {
18028
- ServiceExecutorError[ServiceExecutorError["NoLookup"] = 0] = "NoLookup";
18029
- ServiceExecutorError[ServiceExecutorError["NoState"] = 1] = "NoState";
18030
- ServiceExecutorError[ServiceExecutorError["NoServiceCode"] = 2] = "NoServiceCode";
18031
- ServiceExecutorError[ServiceExecutorError["ServiceCodeMismatch"] = 3] = "ServiceCodeMismatch";
18032
- })(ServiceExecutorError || (ServiceExecutorError = {}));
18033
- class WorkPackageExecutor {
18034
- blocks;
18035
- state;
18036
- hasher;
18037
- constructor(blocks, state, hasher) {
18038
- this.blocks = blocks;
18039
- this.state = state;
18040
- this.hasher = hasher;
18041
- }
18042
- // TODO [ToDr] this while thing should be triple-checked with the GP.
18043
- // I'm currently implementing some dirty version for the demo.
18044
- async executeWorkPackage(pack) {
18045
- const headerHash = pack.context.lookupAnchor;
18046
- // execute authorisation first or is it already executed and we just need to check it?
18047
- const authExec = this.getServiceExecutor(
18048
- // TODO [ToDr] should this be anchor or lookupAnchor?
18049
- headerHash, pack.authCodeHost, pack.authCodeHash);
18050
- if (authExec.isError) {
18051
- // TODO [ToDr] most likely shouldn't be throw.
18052
- throw new Error(`Could not get authorization executor: ${authExec.error}`);
18053
- }
18054
- const pvm = authExec.ok;
18055
- const authGas = tryAsGas(15000n);
18056
- const result = await pvm.run(pack.parametrization, authGas);
18057
- if (!result.isEqualTo(pack.authorization)) {
18058
- throw new Error("Authorization is invalid.");
18059
- }
18060
- const results = [];
18061
- for (const item of pack.items) {
18062
- const exec = this.getServiceExecutor(headerHash, item.service, item.codeHash);
18063
- if (exec.isError) {
18064
- throw new Error(`Could not get item executor: ${exec.error}`);
18065
- }
18066
- const pvm = exec.ok;
18067
- const gasRatio = tryAsServiceGas(3000n);
18068
- const ret = await pvm.run(item.payload, tryAsGas(item.refineGasLimit)); // or accumulateGasLimit?
18069
- results.push(WorkResult.create({
18070
- serviceId: item.service,
18071
- codeHash: item.codeHash,
18072
- payloadHash: hashBytes(item.payload),
18073
- gas: gasRatio,
18074
- result: new WorkExecResult(WorkExecResultKind.ok, ret),
18075
- load: WorkRefineLoad.create({
18076
- gasUsed: tryAsServiceGas(5),
18077
- importedSegments: tryAsU32(0),
18078
- exportedSegments: tryAsU32(0),
18079
- extrinsicSize: tryAsU32(0),
18080
- extrinsicCount: tryAsU32(0),
18081
- }),
18082
- }));
18083
- }
18084
- const workPackage = this.hasher.workPackage(pack);
18085
- const workPackageSpec = WorkPackageSpec.create({
18086
- hash: workPackage.hash,
18087
- length: tryAsU32(workPackage.encoded.length),
18088
- erasureRoot: Bytes.zero(HASH_SIZE),
18089
- exportsRoot: Bytes.zero(HASH_SIZE).asOpaque(),
18090
- exportsCount: tryAsU16(0),
18091
- });
18092
- const coreIndex = tryAsCoreIndex(0);
18093
- const authorizerHash = Bytes.fill(HASH_SIZE, 5).asOpaque();
18094
- const workResults = FixedSizeArray.new(results, tryAsWorkItemsCount(results.length));
18095
- return Promise.resolve(WorkReport.create({
18096
- workPackageSpec,
18097
- context: pack.context,
18098
- coreIndex,
18099
- authorizerHash,
18100
- authorizationOutput: pack.authorization,
18101
- segmentRootLookup: [],
18102
- results: workResults,
18103
- authorizationGasUsed: tryAsServiceGas(0),
18104
- }));
18105
- }
18106
- getServiceExecutor(lookupAnchor, serviceId, expectedCodeHash) {
18107
- const header = this.blocks.getHeader(lookupAnchor);
18108
- if (header === null) {
18109
- return Result$1.error(ServiceExecutorError.NoLookup);
18110
- }
18111
- const state = this.state.getState(lookupAnchor);
18112
- if (state === null) {
18113
- return Result$1.error(ServiceExecutorError.NoState);
18114
- }
18115
- const service = state.getService(serviceId);
18116
- const serviceCodeHash = service?.getInfo().codeHash ?? null;
18117
- if (serviceCodeHash === null) {
18118
- return Result$1.error(ServiceExecutorError.NoServiceCode);
18119
- }
18120
- if (!serviceCodeHash.isEqualTo(expectedCodeHash)) {
18121
- return Result$1.error(ServiceExecutorError.ServiceCodeMismatch);
18122
- }
18123
- const serviceCode = service?.getPreimage(serviceCodeHash.asOpaque()) ?? null;
18124
- if (serviceCode === null) {
18125
- return Result$1.error(ServiceExecutorError.NoServiceCode);
18126
- }
18127
- return Result$1.ok(new PvmExecutor(serviceCode));
18128
- }
18129
- }
18130
- class PvmExecutor {
18131
- serviceCode;
18132
- pvm;
18133
- hostCalls = new HostCallsManager({ missing: new Missing() });
18134
- pvmInstanceManager = new InterpreterInstanceManager(4);
18135
- constructor(serviceCode) {
18136
- this.serviceCode = serviceCode;
18137
- this.pvm = new HostCalls(this.pvmInstanceManager, this.hostCalls);
18138
- }
18139
- async run(args, gas) {
18140
- const program = Program.fromSpi(this.serviceCode.raw, args.raw, true);
18141
- const result = await this.pvm.runProgram(program.code, 5, gas, program.registers, program.memory);
18142
- if (result.hasMemorySlice()) {
18143
- return BytesBlob.blobFrom(result.memorySlice);
18144
- }
18145
- return BytesBlob.empty();
18146
- }
18147
- }
18148
-
18149
17427
  var index = /*#__PURE__*/Object.freeze({
18150
17428
  __proto__: null,
18151
17429
  Preimages: Preimages,
18152
17430
  get PreimagesErrorCode () { return PreimagesErrorCode; },
18153
- TransitionHasher: TransitionHasher,
18154
- WorkPackageExecutor: WorkPackageExecutor
17431
+ TransitionHasher: TransitionHasher
18155
17432
  });
18156
17433
 
18157
17434
  exports.block = index$l;
@@ -18161,11 +17438,11 @@ exports.codec = index$q;
18161
17438
  exports.collections = index$n;
18162
17439
  exports.config = index$m;
18163
17440
  exports.config_node = index$h;
18164
- exports.crypto = index$o;
17441
+ exports.crypto = index$p;
18165
17442
  exports.database = index$d;
18166
17443
  exports.erasure_coding = index$c;
18167
17444
  exports.fuzz_proto = index$a;
18168
- exports.hash = index$p;
17445
+ exports.hash = index$o;
18169
17446
  exports.jam_host_calls = index$9;
18170
17447
  exports.json_parser = index$k;
18171
17448
  exports.logger = index$i;