PHP WebShell
Текущая директория: /opt/BitGoJS/node_modules/@polkadot-api/substrate-bindings/dist
Просмотр файла: index.mjs
var __defProp = Object.defineProperty;
var __typeError = (msg) => {
throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
// src/codecs/scale/AccountId.ts
import { Bytes, enhanceCodec } from "scale-ts";
// src/utils/ss58-util.ts
import { base58 } from "@scure/base";
import { blake2b } from "@noble/hashes/blake2b";
var SS58_PREFIX = new TextEncoder().encode("SS58PRE");
var CHECKSUM_LENGTH = 2;
var getSs58AddressInfo = (address) => {
try {
const decoded = base58.decode(address);
const prefixBytes = decoded.subarray(0, decoded[0] & 64 ? 2 : 1);
const publicKey = decoded.subarray(
prefixBytes.length,
decoded.length - CHECKSUM_LENGTH
);
const checksum = decoded.subarray(prefixBytes.length + publicKey.length);
const expectedChecksum = blake2b(
Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey),
{
dkLen: 64
}
).subarray(0, CHECKSUM_LENGTH);
const isChecksumValid = checksum[0] === expectedChecksum[0] && checksum[1] === expectedChecksum[1];
if (!isChecksumValid) return { isValid: false };
return {
isValid: true,
ss58Format: prefixBytesToNumber(prefixBytes),
publicKey: publicKey.slice()
};
} catch (_) {
return { isValid: false };
}
};
var prefixBytesToNumber = (bytes) => {
const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
return dv.byteLength === 1 ? dv.getUint8(0) : dv.getUint16(0);
};
var fromBufferToBase58 = (ss58Format) => {
const prefixBytes = ss58Format < 64 ? Uint8Array.of(ss58Format) : Uint8Array.of(
(ss58Format & 252) >> 2 | 64,
ss58Format >> 8 | (ss58Format & 3) << 6
);
return (publicKey) => {
const checksum = blake2b(
Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey),
{
dkLen: 64
}
).subarray(0, CHECKSUM_LENGTH);
return base58.encode(
Uint8Array.of(...prefixBytes, ...publicKey, ...checksum)
);
};
};
// src/codecs/scale/AccountId.ts
function fromBase58ToBuffer(nBytes, _ss58Format) {
return (address) => {
const info = getSs58AddressInfo(address);
if (!info.isValid) throw new Error("Invalid checksum");
const { publicKey } = info;
if (publicKey.length !== nBytes)
throw new Error("Invalid public key length");
return publicKey;
};
}
var AccountId = (ss58Format = 42, nBytes = 32) => enhanceCodec(
Bytes(nBytes),
fromBase58ToBuffer(nBytes, ss58Format),
fromBufferToBase58(ss58Format)
);
// src/codecs/scale/Binary.ts
import { Bytes as Bytes2, createCodec } from "scale-ts";
import { fromHex, toHex } from "@polkadot-api/utils";
var textEncoder = new TextEncoder();
var textDecoder = new TextDecoder();
var _bytes, _hex, _str;
var _Binary = class _Binary {
constructor(data) {
__privateAdd(this, _bytes);
__privateAdd(this, _hex, null);
__privateAdd(this, _str, null);
__publicField(this, "asText", () => __privateGet(this, _str) === null ? __privateSet(this, _str, textDecoder.decode(__privateGet(this, _bytes))) : __privateGet(this, _str));
__publicField(this, "asHex", () => __privateGet(this, _hex) === null ? __privateSet(this, _hex, toHex(__privateGet(this, _bytes))) : __privateGet(this, _hex));
__publicField(this, "asBytes", () => __privateGet(this, _bytes));
__privateSet(this, _bytes, data);
}
static fromText(input) {
return new _Binary(textEncoder.encode(input));
}
static fromHex(input) {
return new _Binary(fromHex(input));
}
static fromBytes(input) {
return new _Binary(input);
}
};
_bytes = new WeakMap();
_hex = new WeakMap();
_str = new WeakMap();
var Binary = _Binary;
var FixedSizeBinary = class _FixedSizeBinary extends Binary {
constructor(data) {
super(data);
}
static fromArray(input) {
return new _FixedSizeBinary(new Uint8Array(input));
}
};
var enc = (nBytes) => {
const _enc = Bytes2.enc(nBytes);
return (value) => _enc(value.asBytes());
};
var dec = (nBytes) => {
const _dec = Bytes2.dec(nBytes);
return (value) => Binary.fromBytes(_dec(value));
};
var Bin = (nBytes) => createCodec(enc(nBytes), dec(nBytes));
Bin.enc = enc;
Bin.dec = dec;
// src/codecs/scale/bitSequence.ts
import { Bytes as Bytes3, createCodec as createCodec2, createDecoder } from "scale-ts";
// src/codecs/scale/compact.ts
import { compact } from "scale-ts";
var compactNumber = compact;
var compactBn = compact;
// src/codecs/scale/bitSequence.ts
var bitSequenceDecoder = createDecoder((data) => {
const bitsLen = compactNumber.dec(data);
const bytesLen = Math.ceil(bitsLen / 8);
const bytes = Bytes3(bytesLen).dec(data);
return { bytes, bitsLen };
});
var bitSequenceEncoder = (input) => {
if (input.bitsLen > input.bytes.length * 8)
throw new Error(
`Not enough bytes. (bitsLen:${input.bitsLen}, bytesLen:${input.bytes.length})`
);
const lenEncoded = compactNumber.enc(input.bitsLen);
const result = new Uint8Array(input.bytes.length + lenEncoded.length);
result.set(lenEncoded, 0);
result.set(input.bytes, lenEncoded.length);
return result;
};
var bitSequence = createCodec2(bitSequenceEncoder, bitSequenceDecoder);
// src/codecs/scale/char.ts
import { enhanceCodec as enhanceCodec2, u8 } from "scale-ts";
var char = enhanceCodec2(
u8,
(str8) => str8.charCodeAt(0),
String.fromCharCode
);
// src/codecs/scale/Hex.ts
import { fromHex as fromHex2, toHex as toHex2 } from "@polkadot-api/utils";
import { Bytes as Bytes4, createCodec as createCodec3 } from "scale-ts";
var enc2 = (nBytes) => {
const _enc = Bytes4.enc(nBytes);
return (value) => _enc(fromHex2(value));
};
var dec2 = (nBytes) => {
const _dec = Bytes4.dec(nBytes);
return (value) => toHex2(_dec(value));
};
var Hex = (nBytes) => createCodec3(enc2(nBytes), dec2(nBytes));
Hex.enc = enc2;
Hex.dec = dec2;
// src/codecs/scale/fixed-str.ts
import { Bytes as Bytes5, enhanceCodec as enhanceCodec3 } from "scale-ts";
var textEncoder2 = new TextEncoder();
var textDecoder2 = new TextDecoder();
var fixedStr = (nBytes) => enhanceCodec3(
Bytes5(nBytes),
(str8) => textEncoder2.encode(str8),
(bytes) => textDecoder2.decode(bytes)
);
// src/codecs/scale/re-exported.ts
import {
_void,
bool,
compact as compact2,
str,
u8 as u82,
u16,
u32,
u64,
u128,
u256,
i8,
i16,
i32,
i64,
i128,
i256,
Option,
Result,
Vector,
Tuple,
Struct,
Bytes as Bytes6,
Enum,
enhanceCodec as enhanceCodec4,
enhanceEncoder,
enhanceDecoder,
createCodec as createCodec4,
createDecoder as createDecoder2
} from "scale-ts";
// src/codecs/scale/Self.ts
import { createCodec as createCodec5 } from "scale-ts";
var selfEncoder = (value) => {
let cache = (x) => {
const encoder = value();
cache = encoder;
return encoder(x);
};
return (x) => cache(x);
};
var selfDecoder = (value) => {
let cache = (x) => {
const decoder = value();
const result = decoder;
cache = decoder;
return result(x);
};
return (x) => cache(x);
};
var Self = (value) => createCodec5(
selfEncoder(() => value().enc),
selfDecoder(() => value().dec)
);
// src/codecs/scale/Variant.ts
import {
Enum as ScaleEnum,
createCodec as createCodec6
} from "scale-ts";
import { mapObject } from "@polkadot-api/utils";
// src/types/enum.ts
var discriminant = {
is(value, type) {
return value.type === type;
},
as(value, type) {
if (type !== value.type)
throw new Error(
`Enum.as(enum, ${type}) used with actual type ${value.type}`
);
return value;
}
};
var Enum2 = Object.assign((type, value) => {
return {
type,
value
};
}, discriminant);
var _Enum = new Proxy(
{},
{
get(_, prop) {
return (value) => Enum2(prop, value);
}
}
);
// src/codecs/scale/Variant.ts
var VariantEnc = (...args) => {
const enc3 = ScaleEnum.enc(...args);
return (v) => enc3({ tag: v.type, value: v.value });
};
var VariantDec = (...args) => {
const dec3 = ScaleEnum.dec(...args);
return (v) => {
const { tag, value } = dec3(v);
return Enum2(tag, value);
};
};
var Variant = (inner, ...args) => createCodec6(
VariantEnc(
mapObject(inner, ([encoder]) => encoder),
...args
),
VariantDec(
mapObject(inner, ([, decoder]) => decoder),
...args
)
);
Variant.enc = VariantEnc;
Variant.dec = VariantDec;
// src/codecs/scale/ethAccount.ts
import { fromHex as fromHex3, toHex as toHex3 } from "@polkadot-api/utils";
import { Bytes as Bytes7, createCodec as createCodec7, createDecoder as createDecoder3 } from "scale-ts";
import { keccak_256 as keccak } from "@noble/hashes/sha3";
var getFormattedAddress = (hexAddress) => {
const nonChecksum = hexAddress.slice(2);
const hashedAddress = toHex3(keccak(nonChecksum)).slice(2);
const result = new Array(40);
for (let i = 0; i < 40; i++) {
const checksumVal = parseInt(hashedAddress[i], 16);
const char2 = nonChecksum[i];
result[i] = checksumVal > 7 ? char2.toUpperCase() : char2;
}
return `0x${result.join("")}`;
};
var bytes20Dec = Bytes7(20)[1];
var ethAccount = createCodec7(
(input) => {
const bytes = fromHex3(input);
if (bytes.length !== 20)
throw new Error(`Invalid length found on EthAddress(${input})`);
const hexAddress = toHex3(bytes);
if (input === hexAddress || input === hexAddress.toUpperCase()) return bytes;
if (getFormattedAddress(hexAddress) !== input)
throw new Error(`Invalid checksum found on EthAddress(${input})`);
return bytes;
},
createDecoder3((bytes) => getFormattedAddress(toHex3(bytes20Dec(bytes))))
);
// src/codecs/blockHeader.ts
var textEncoder3 = new TextEncoder();
var textDecoder3 = new TextDecoder();
var fourChars = enhanceCodec4(
Bytes6(4),
textEncoder3.encode.bind(textEncoder3),
textDecoder3.decode.bind(textDecoder3)
);
var diggestVal = Struct({
engine: fourChars,
payload: Hex()
});
var diggest = Variant(
{
consensus: diggestVal,
seal: diggestVal,
preRuntime: diggestVal,
runtimeUpdated: _void
},
[4, 5, 6, 8]
);
var hex32 = Hex(32);
var blockHeader = Struct({
parentHash: hex32,
number: compactNumber,
stateRoot: hex32,
extrinsicRoot: hex32,
digests: Vector(diggest)
});
// src/codecs/metadata/metadata.ts
import { Enum as Enum5, Struct as Struct7, u32 as u323, createCodec as createCodec9 } from "scale-ts";
// src/codecs/metadata/v15.ts
import { Struct as Struct5, Tuple as Tuple2, Vector as Vector6, str as str6, u8 as u85 } from "scale-ts";
// src/codecs/metadata/lookup.ts
import {
Enum as Enum3,
Option as Option2,
Struct as Struct2,
Vector as Vector3,
_void as _void3,
str as str3,
u32 as u322,
u8 as u83
} from "scale-ts";
// src/codecs/metadata/docs.ts
import { Vector as Vector2, str as str2 } from "scale-ts";
var docs = Vector2(str2);
// src/codecs/metadata/lookup.ts
var oStr = Option2(str3);
var primitive = Enum3({
bool: _void3,
char: _void3,
str: _void3,
u8: _void3,
u16: _void3,
u32: _void3,
u64: _void3,
u128: _void3,
u256: _void3,
i8: _void3,
i16: _void3,
i32: _void3,
i64: _void3,
i128: _void3,
i256: _void3
});
var fields = Vector3(
Struct2({
name: oStr,
type: compactNumber,
typeName: oStr,
docs
})
);
var arr = Struct2({
len: u322,
type: compactNumber
});
var bitSequence2 = Struct2({
bitStoreType: compactNumber,
bitOrderType: compactNumber
});
var variant = Vector3(
Struct2({
name: str3,
fields,
index: u83,
docs
})
);
var def = Enum3({
composite: fields,
variant,
sequence: compactNumber,
array: arr,
tuple: Vector3(compactNumber),
primitive,
compact: compactNumber,
bitSequence: bitSequence2
});
var param = Struct2({
name: str3,
type: Option2(compactNumber)
});
var params = Vector3(param);
var entry = Struct2({
id: compactNumber,
path: docs,
params,
def,
docs
});
var lookup = Vector3(entry);
// src/codecs/metadata/pallets.ts
import { Struct as Struct3, Option as Option3, Vector as Vector4, u8 as u84, str as str4, Enum as Enum4, _void as _void4 } from "scale-ts";
var hashType = Enum4({
Blake2128: _void4,
Blake2256: _void4,
Blake2128Concat: _void4,
Twox128: _void4,
Twox256: _void4,
Twox64Concat: _void4,
Identity: _void4
});
var hashers = Vector4(hashType);
var storageMap = Struct3({
hashers,
key: compactNumber,
value: compactNumber
});
var storageItem = Struct3({
name: str4,
modifier: u84,
type: Enum4({
plain: compactNumber,
map: storageMap
}),
fallback: Hex(),
docs
});
var storage = Option3(
Struct3({
prefix: str4,
items: Vector4(storageItem)
})
);
var v14Pallet = {
name: str4,
storage,
calls: Option3(compactNumber),
events: Option3(compactNumber),
constants: Vector4(
Struct3({
name: str4,
type: compactNumber,
value: Hex(),
docs
})
),
errors: Option3(compactNumber),
index: u84
};
var v15Pallet = {
...v14Pallet,
docs
};
// src/codecs/metadata/runtime-api.ts
import { Struct as Struct4, Vector as Vector5, str as str5 } from "scale-ts";
var runtimeApi = Struct4({
name: str5,
methods: Vector5(
Struct4({
name: str5,
inputs: Vector5(
Struct4({
name: str5,
type: compactNumber
})
),
output: compactNumber,
docs
})
),
docs
});
// src/codecs/metadata/v15.ts
var extrinsic = Struct5({
version: u85,
address: compactNumber,
call: compactNumber,
signature: compactNumber,
extra: compactNumber,
signedExtensions: Vector6(
Struct5({
identifier: str6,
type: compactNumber,
additionalSigned: compactNumber
})
)
});
var v15 = Struct5({
lookup,
pallets: Vector6(Struct5(v15Pallet)),
extrinsic,
type: compactNumber,
apis: Vector6(runtimeApi),
outerEnums: Struct5({
call: compactNumber,
event: compactNumber,
error: compactNumber
}),
custom: Vector6(Tuple2(str6, Struct5({ type: compactNumber, value: Hex() })))
});
// src/codecs/metadata/v14.ts
import { Struct as Struct6, Vector as Vector7, createCodec as createCodec8, str as str7, u8 as u86 } from "scale-ts";
var empty = new Uint8Array();
var Always = (value) => createCodec8(
() => empty,
() => value
);
var extrinsic2 = Struct6({
type: compactNumber,
version: u86,
signedExtensions: Vector7(
Struct6({
identifier: str7,
type: compactNumber,
additionalSigned: compactNumber
})
)
});
var v14 = Struct6({
lookup,
pallets: Vector7(Struct6({ ...v14Pallet, docs: Always([]) })),
extrinsic: extrinsic2,
type: compactNumber,
apis: Always([])
});
// src/codecs/metadata/metadata.ts
var unsupportedFn = () => {
throw new Error("Unsupported metadata version!");
};
var unsupported = createCodec9(
unsupportedFn,
unsupportedFn
);
var metadata = Struct7({
magicNumber: u323,
metadata: Enum5({
v0: unsupported,
v1: unsupported,
v2: unsupported,
v3: unsupported,
v4: unsupported,
v5: unsupported,
v6: unsupported,
v7: unsupported,
v8: unsupported,
v9: unsupported,
v10: unsupported,
v11: unsupported,
v12: unsupported,
v13: unsupported,
v14,
v15
})
});
// src/hashes/blake2.ts
import { mergeUint8 } from "@polkadot-api/utils";
import { blake2b as blake2b2 } from "@noble/hashes/blake2b";
var len32 = { dkLen: 32 };
var Blake2256 = (encoded) => blake2b2(encoded, len32);
var len16 = { dkLen: 16 };
var Blake2128 = (encoded) => blake2b2(encoded, len16);
var Blake2128Concat = (encoded) => mergeUint8(Blake2128(encoded), encoded);
// src/hashes/blake3.ts
import { mergeUint8 as mergeUint82 } from "@polkadot-api/utils";
import { blake3 } from "@noble/hashes/blake3";
var len322 = { dkLen: 32 };
var Blake3256 = (encoded) => blake3(encoded, len322);
var Blake3256Concat = (encoded) => mergeUint82(Blake3256(encoded), encoded);
// src/hashes/identity.ts
var Identity = (encoded) => encoded;
// src/hashes/twoX.ts
import { mergeUint8 as mergeUint83 } from "@polkadot-api/utils";
import { u64 as u642 } from "scale-ts";
// src/hashes/h64.ts
var bigintFromU16 = (v0, v1, v2, v3) => new DataView(new Uint16Array([v0, v1, v2, v3]).buffer).getBigUint64(0, true);
var MASK_64 = 2n ** 64n - 1n;
var rotl = (input, nBits) => input << nBits & MASK_64 | input >> 64n - nBits;
var multiply = (a, b) => a * b & MASK_64;
var add = (a, b) => a + b & MASK_64;
var PRIME64_1 = 11400714785074694791n;
var PRIME64_2 = 14029467366897019727n;
var PRIME64_3 = 1609587929392839161n;
var PRIME64_4 = 9650029242287828579n;
var PRIME64_5 = 2870177450012600261n;
function h64(input, seed = 0n) {
let v1 = add(add(seed, PRIME64_1), PRIME64_2);
let v2 = add(seed, PRIME64_2);
let v3 = seed;
let v4 = seed - PRIME64_1;
let totalLen = input.length;
let memsize = 0;
let memory = null;
(function update() {
let p2 = 0;
let bEnd = p2 + totalLen;
if (!totalLen) return;
memory = new Uint8Array(32);
if (totalLen < 32) {
memory.set(input.subarray(0, totalLen), memsize);
memsize += totalLen;
return;
}
if (p2 <= bEnd - 32) {
const limit = bEnd - 32;
do {
let other;
other = bigintFromU16(
input[p2 + 1] << 8 | input[p2],
input[p2 + 3] << 8 | input[p2 + 2],
input[p2 + 5] << 8 | input[p2 + 4],
input[p2 + 7] << 8 | input[p2 + 6]
);
v1 = multiply(rotl(add(v1, multiply(other, PRIME64_2)), 31n), PRIME64_1);
p2 += 8;
other = bigintFromU16(
input[p2 + 1] << 8 | input[p2],
input[p2 + 3] << 8 | input[p2 + 2],
input[p2 + 5] << 8 | input[p2 + 4],
input[p2 + 7] << 8 | input[p2 + 6]
);
v2 = multiply(rotl(add(v2, multiply(other, PRIME64_2)), 31n), PRIME64_1);
p2 += 8;
other = bigintFromU16(
input[p2 + 1] << 8 | input[p2],
input[p2 + 3] << 8 | input[p2 + 2],
input[p2 + 5] << 8 | input[p2 + 4],
input[p2 + 7] << 8 | input[p2 + 6]
);
v3 = multiply(rotl(add(v3, multiply(other, PRIME64_2)), 31n), PRIME64_1);
p2 += 8;
other = bigintFromU16(
input[p2 + 1] << 8 | input[p2],
input[p2 + 3] << 8 | input[p2 + 2],
input[p2 + 5] << 8 | input[p2 + 4],
input[p2 + 7] << 8 | input[p2 + 6]
);
v4 = multiply(rotl(add(v4, multiply(other, PRIME64_2)), 31n), PRIME64_1);
p2 += 8;
} while (p2 <= limit);
}
if (p2 < bEnd) {
memory.set(input.subarray(p2, bEnd), memsize);
memsize = bEnd - p2;
}
})();
input = memory || input;
let result;
let p = 0;
if (totalLen >= 32) {
result = rotl(v1, 1n);
result = add(result, rotl(v2, 7n));
result = add(result, rotl(v3, 12n));
result = add(result, rotl(v4, 18n));
v1 = multiply(rotl(multiply(v1, PRIME64_2), 31n), PRIME64_1);
result = result ^ v1;
result = add(multiply(result, PRIME64_1), PRIME64_4);
v2 = multiply(rotl(multiply(v2, PRIME64_2), 31n), PRIME64_1);
result = result ^ v2;
result = add(multiply(result, PRIME64_1), PRIME64_4);
v3 = multiply(rotl(multiply(v3, PRIME64_2), 31n), PRIME64_1);
result = result ^ v3;
result = add(multiply(result, PRIME64_1), PRIME64_4);
v4 = multiply(rotl(multiply(v4, PRIME64_2), 31n), PRIME64_1);
result = result ^ v4;
result = add(multiply(result, PRIME64_1), PRIME64_4);
} else {
result = add(seed, PRIME64_5);
}
result = add(result, BigInt(totalLen));
while (p <= memsize - 8) {
let temp2 = bigintFromU16(
input[p + 1] << 8 | input[p],
input[p + 3] << 8 | input[p + 2],
input[p + 5] << 8 | input[p + 4],
input[p + 7] << 8 | input[p + 6]
);
temp2 = multiply(rotl(multiply(temp2, PRIME64_2), 31n), PRIME64_1);
result = add(multiply(rotl(result ^ temp2, 27n), PRIME64_1), PRIME64_4);
p += 8;
}
if (p + 4 <= memsize) {
let temp2 = multiply(
bigintFromU16(
input[p + 1] << 8 | input[p],
input[p + 3] << 8 | input[p + 2],
0,
0
),
PRIME64_1
);
result = add(multiply(rotl(result ^ temp2, 23n), PRIME64_2), PRIME64_3);
p += 4;
}
while (p < memsize) {
const temp2 = multiply(bigintFromU16(input[p++], 0, 0, 0), PRIME64_5);
result = multiply(rotl(result ^ temp2, 11n), PRIME64_1);
}
let temp = result >> 33n;
result = multiply(result ^ temp, PRIME64_2);
temp = result >> 29n;
result = multiply(result ^ temp, PRIME64_3);
temp = result >> 32n;
result ^= temp;
return result;
}
// src/hashes/twoX.ts
var Twox128 = (input) => {
const result = new Uint8Array(16);
const dv = new DataView(result.buffer);
dv.setBigUint64(0, h64(input), true);
dv.setBigUint64(8, h64(input, 1n), true);
return result;
};
var Twox256 = (input) => {
const result = new Uint8Array(32);
const dv = new DataView(result.buffer);
dv.setBigUint64(0, h64(input), true);
dv.setBigUint64(8, h64(input, 1n), true);
dv.setBigUint64(16, h64(input, 2n), true);
dv.setBigUint64(24, h64(input, 3n), true);
return result;
};
var Twox64Concat = (encoded) => mergeUint83(u642.enc(h64(encoded)), encoded);
// src/storage.ts
import { mergeUint8 as mergeUint84, toHex as toHex4 } from "@polkadot-api/utils";
var textEncoder4 = new TextEncoder();
var Storage = (pallet) => {
const palledEncoded = Twox128(textEncoder4.encode(pallet));
return (name, dec3, ...encoders) => {
const palletItemEncoded = mergeUint84(
palledEncoded,
Twox128(textEncoder4.encode(name))
);
const palletItemEncodedHex = toHex4(palletItemEncoded);
const bytesToSkip = encoders.map((e) => e[1]).map((x) => {
if (x === Identity) return 0;
if (x === Twox64Concat) return 8;
if (x === Blake2128Concat) return 16;
return null;
}).filter(Boolean);
const keyDecoder = (key) => {
if (!key.startsWith(palletItemEncodedHex))
throw new Error(`key does not match this storage (${pallet}.${name})`);
if (bytesToSkip.length !== encoders.length)
throw new Error("Impossible to decode this key");
if (encoders.length === 0) return [];
const argsKey = key.slice(palletItemEncodedHex.length);
const result = new Array(encoders.length);
for (let i = 0, cur = 0; i < bytesToSkip.length; i++) {
const codec = encoders[i][0];
cur += bytesToSkip[i];
result[i] = codec.dec(argsKey.slice(cur * 2));
cur += codec.enc(result[i]).length;
}
return result;
};
const fns = encoders.map(
([{ enc: enc4 }, hash]) => (val) => hash(enc4(val))
);
const enc3 = (...args) => toHex4(
mergeUint84(palletItemEncoded, ...args.map((val, idx) => fns[idx](val)))
);
return {
enc: enc3,
dec: dec3,
keyDecoder
};
};
};
export {
AccountId,
Bin,
Binary,
Blake2128,
Blake2128Concat,
Blake2256,
Blake3256,
Blake3256Concat,
Bytes6 as Bytes,
Enum2 as Enum,
FixedSizeBinary,
Hex,
Identity,
Option,
Result,
Enum as ScaleEnum,
Self,
Storage,
Struct,
Tuple,
Twox128,
Twox256,
Twox64Concat,
Variant,
Vector,
_Enum,
_void,
bitSequence,
blockHeader,
bool,
char,
compact2 as compact,
compactBn,
compactNumber,
createCodec4 as createCodec,
createDecoder2 as createDecoder,
enhanceCodec4 as enhanceCodec,
enhanceDecoder,
enhanceEncoder,
ethAccount,
fixedStr,
fromBufferToBase58,
getSs58AddressInfo,
h64,
i128,
i16,
i256,
i32,
i64,
i8,
metadata,
selfDecoder,
selfEncoder,
str,
u128,
u16,
u256,
u32,
u64,
u82 as u8,
v14,
v15
};
//# sourceMappingURL=index.mjs.mapВыполнить команду
Для локальной разработки. Не используйте в интернете!