@hyperlane-xyz/cli
Version:
A command-line utility for common Hyperlane operations
1,232 lines (1,180 loc) • 399 kB
JavaScript
export const id = 756;
export const ids = [756];
export const modules = {
/***/ 96659:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ mQ: () => (/* binding */ BASE_ACCOUNT_SIZE),
/* harmony export */ oG: () => (/* binding */ fetchEncodedAccount)
/* harmony export */ });
/* unused harmony exports assertAccountDecoded, assertAccountExists, assertAccountsDecoded, assertAccountsExist, decodeAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount */
/* harmony import */ var _solana_codecs_strings__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98915);
// src/account.ts
var BASE_ACCOUNT_SIZE = 128;
function decodeAccount(encodedAccount, decoder) {
try {
if ("exists" in encodedAccount && !encodedAccount.exists) {
return encodedAccount;
}
return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
} catch {
throw new SolanaError(SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT, {
address: encodedAccount.address
});
}
}
function accountExists(account) {
return !("exists" in account) || "exists" in account && account.exists;
}
function assertAccountDecoded(account) {
if (accountExists(account) && account.data instanceof Uint8Array) {
throw new SolanaError(SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT, {
address: account.address
});
}
}
function assertAccountsDecoded(accounts) {
const encoded = accounts.filter((a) => accountExists(a) && a.data instanceof Uint8Array);
if (encoded.length > 0) {
const encodedAddresses = encoded.map((a) => a.address);
throw new SolanaError(SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED, {
addresses: encodedAddresses
});
}
}
function parseBase64RpcAccount(address, rpcAccount) {
if (!rpcAccount) return Object.freeze({ address, exists: false });
const data = (0,_solana_codecs_strings__WEBPACK_IMPORTED_MODULE_0__/* .getBase64Encoder */ .Iz)().encode(rpcAccount.data[0]);
return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
}
function parseBase58RpcAccount(address, rpcAccount) {
if (!rpcAccount) return Object.freeze({ address, exists: false });
const data = getBase58Encoder().encode(typeof rpcAccount.data === "string" ? rpcAccount.data : rpcAccount.data[0]);
return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
}
function parseJsonRpcAccount(address, rpcAccount) {
if (!rpcAccount) return Object.freeze({ address, exists: false });
const data = rpcAccount.data.parsed.info || {};
if (rpcAccount.data.program || rpcAccount.data.parsed.type) {
data.parsedAccountMeta = {
program: rpcAccount.data.program,
type: rpcAccount.data.parsed.type
};
}
return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
}
function parseBaseAccount(rpcAccount) {
return Object.freeze({
executable: rpcAccount.executable,
lamports: rpcAccount.lamports,
programAddress: rpcAccount.owner,
space: rpcAccount.space
});
}
// src/fetch-account.ts
async function fetchEncodedAccount(rpc, address, config = {}) {
const { abortSignal, ...rpcConfig } = config;
const response = await rpc.getAccountInfo(address, { ...rpcConfig, encoding: "base64" }).send({ abortSignal });
return parseBase64RpcAccount(address, response.value);
}
async function fetchJsonParsedAccount(rpc, address, config = {}) {
const { abortSignal, ...rpcConfig } = config;
const { value: account } = await rpc.getAccountInfo(address, { ...rpcConfig, encoding: "jsonParsed" }).send({ abortSignal });
return !!account && typeof account === "object" && "parsed" in account.data ? parseJsonRpcAccount(address, account) : parseBase64RpcAccount(address, account);
}
async function fetchEncodedAccounts(rpc, addresses, config = {}) {
const { abortSignal, ...rpcConfig } = config;
const response = await rpc.getMultipleAccounts(addresses, { ...rpcConfig, encoding: "base64" }).send({ abortSignal });
return response.value.map((account, index) => parseBase64RpcAccount(addresses[index], account));
}
async function fetchJsonParsedAccounts(rpc, addresses, config = {}) {
const { abortSignal, ...rpcConfig } = config;
const response = await rpc.getMultipleAccounts(addresses, { ...rpcConfig, encoding: "jsonParsed" }).send({ abortSignal });
return response.value.map((account, index) => {
return !!account && typeof account === "object" && "parsed" in account.data ? parseJsonRpcAccount(addresses[index], account) : parseBase64RpcAccount(addresses[index], account);
});
}
function assertAccountExists(account) {
if (!account.exists) {
throw new SolanaError(SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND, { address: account.address });
}
}
function assertAccountsExist(accounts) {
const missingAccounts = accounts.filter((a) => !a.exists);
if (missingAccounts.length > 0) {
const missingAddresses = missingAccounts.map((a) => a.address);
throw new SolanaError(SOLANA_ERROR__ACCOUNTS__ONE_OR_MORE_ACCOUNTS_NOT_FOUND, { addresses: missingAddresses });
}
}
//# sourceMappingURL=index.node.mjs.map
//# sourceMappingURL=index.node.mjs.map
/***/ }),
/***/ 89735:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ PW: () => (/* binding */ isAddress),
/* harmony export */ Tq: () => (/* binding */ getAddressFromPublicKey),
/* harmony export */ Vm: () => (/* binding */ assertIsAddress),
/* harmony export */ XF: () => (/* binding */ getAddressComparator),
/* harmony export */ Xg: () => (/* binding */ getAddressDecoder),
/* harmony export */ hl: () => (/* binding */ address),
/* harmony export */ jb: () => (/* binding */ getAddressCodec),
/* harmony export */ jw: () => (/* binding */ getAddressEncoder),
/* harmony export */ o0: () => (/* binding */ getProgramDerivedAddress)
/* harmony export */ });
/* unused harmony exports assertIsOffCurveAddress, assertIsProgramDerivedAddress, createAddressWithSeed, getPublicKeyFromAddress, isOffCurveAddress, isProgramDerivedAddress, offCurveAddress */
/* harmony import */ var _solana_codecs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(32163);
/* harmony import */ var _solana_codecs_strings__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98915);
/* harmony import */ var _solana_errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(13197);
/* harmony import */ var _solana_assertions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40305);
// src/address.ts
var memoizedBase58Encoder;
var memoizedBase58Decoder;
function getMemoizedBase58Encoder() {
if (!memoizedBase58Encoder) memoizedBase58Encoder = (0,_solana_codecs_strings__WEBPACK_IMPORTED_MODULE_0__/* .getBase58Encoder */ .nZ)();
return memoizedBase58Encoder;
}
function getMemoizedBase58Decoder() {
if (!memoizedBase58Decoder) memoizedBase58Decoder = (0,_solana_codecs_strings__WEBPACK_IMPORTED_MODULE_0__/* .getBase58Decoder */ .BC)();
return memoizedBase58Decoder;
}
function isAddress(putativeAddress) {
if (
// Lowest address (32 bytes of zeroes)
putativeAddress.length < 32 || // Highest address (32 bytes of 255)
putativeAddress.length > 44
) {
return false;
}
const base58Encoder = getMemoizedBase58Encoder();
try {
return base58Encoder.encode(putativeAddress).byteLength === 32;
} catch {
return false;
}
}
function assertIsAddress(putativeAddress) {
if (
// Lowest address (32 bytes of zeroes)
putativeAddress.length < 32 || // Highest address (32 bytes of 255)
putativeAddress.length > 44
) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE */ .VCG, {
actualLength: putativeAddress.length
});
}
const base58Encoder = getMemoizedBase58Encoder();
const bytes = base58Encoder.encode(putativeAddress);
const numBytes = bytes.byteLength;
if (numBytes !== 32) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH */ .ncp, {
actualLength: numBytes
});
}
}
function address(putativeAddress) {
assertIsAddress(putativeAddress);
return putativeAddress;
}
function getAddressEncoder() {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_2__/* .transformEncoder */ .FU)(
(0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_2__/* .fixEncoderSize */ .Ns)(getMemoizedBase58Encoder(), 32),
(putativeAddress) => address(putativeAddress)
);
}
function getAddressDecoder() {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_2__/* .fixDecoderSize */ .pI)(getMemoizedBase58Decoder(), 32);
}
function getAddressCodec() {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_2__/* .combineCodec */ .mC)(getAddressEncoder(), getAddressDecoder());
}
function getAddressComparator() {
return new Intl.Collator("en", {
caseFirst: "lower",
ignorePunctuation: false,
localeMatcher: "best fit",
numeric: false,
sensitivity: "variant",
usage: "sort"
}).compare;
}
// src/vendor/noble/ed25519.ts
var D = 37095705934669439343138083508754565189542113879843219016388785533085940283555n;
var P = 57896044618658097711785492504343953926634992332820282019728792003956564819949n;
var RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n;
function mod(a) {
const r = a % P;
return r >= 0n ? r : P + r;
}
function pow2(x, power) {
let r = x;
while (power-- > 0n) {
r *= r;
r %= P;
}
return r;
}
function pow_2_252_3(x) {
const x2 = x * x % P;
const b2 = x2 * x % P;
const b4 = pow2(b2, 2n) * b2 % P;
const b5 = pow2(b4, 1n) * x % P;
const b10 = pow2(b5, 5n) * b5 % P;
const b20 = pow2(b10, 10n) * b10 % P;
const b40 = pow2(b20, 20n) * b20 % P;
const b80 = pow2(b40, 40n) * b40 % P;
const b160 = pow2(b80, 80n) * b80 % P;
const b240 = pow2(b160, 80n) * b80 % P;
const b250 = pow2(b240, 10n) * b10 % P;
const pow_p_5_8 = pow2(b250, 2n) * x % P;
return pow_p_5_8;
}
function uvRatio(u, v) {
const v3 = mod(v * v * v);
const v7 = mod(v3 * v3 * v);
const pow = pow_2_252_3(u * v7);
let x = mod(u * v3 * pow);
const vx2 = mod(v * x * x);
const root1 = x;
const root2 = mod(x * RM1);
const useRoot1 = vx2 === u;
const useRoot2 = vx2 === mod(-u);
const noRoot = vx2 === mod(-u * RM1);
if (useRoot1) x = root1;
if (useRoot2 || noRoot) x = root2;
if ((mod(x) & 1n) === 1n) x = mod(-x);
if (!useRoot1 && !useRoot2) {
return null;
}
return x;
}
function pointIsOnCurve(y, lastByte) {
const y2 = mod(y * y);
const u = mod(y2 - 1n);
const v = mod(D * y2 + 1n);
const x = uvRatio(u, v);
if (x === null) {
return false;
}
const isLastByteOdd = (lastByte & 128) !== 0;
if (x === 0n && isLastByteOdd) {
return false;
}
return true;
}
// src/curve-internal.ts
function byteToHex(byte) {
const hexString = byte.toString(16);
if (hexString.length === 1) {
return `0${hexString}`;
} else {
return hexString;
}
}
function decompressPointBytes(bytes) {
const hexString = bytes.reduce((acc, byte, ii) => `${byteToHex(ii === 31 ? byte & -129 : byte)}${acc}`, "");
const integerLiteralString = `0x${hexString}`;
return BigInt(integerLiteralString);
}
function compressedPointBytesAreOnCurve(bytes) {
if (bytes.byteLength !== 32) {
return false;
}
const y = decompressPointBytes(bytes);
return pointIsOnCurve(y, bytes[31]);
}
// src/curve.ts
function isOffCurveAddress(putativeOffCurveAddress) {
const addressBytes = getAddressCodec().encode(putativeOffCurveAddress);
return compressedPointBytesAreOnCurve(addressBytes) === false;
}
function assertIsOffCurveAddress(putativeOffCurveAddress) {
if (!isOffCurveAddress(putativeOffCurveAddress)) {
throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS);
}
}
function offCurveAddress(putativeOffCurveAddress) {
assertIsOffCurveAddress(putativeOffCurveAddress);
return putativeOffCurveAddress;
}
function isProgramDerivedAddress(value) {
return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "number" && value[1] >= 0 && value[1] <= 255 && isAddress(value[0]);
}
function assertIsProgramDerivedAddress(value) {
const validFormat = Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "number";
if (!validFormat) {
throw new SolanaError(SOLANA_ERROR__ADDRESSES__MALFORMED_PDA);
}
if (value[1] < 0 || value[1] > 255) {
throw new SolanaError(SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE, {
bump: value[1]
});
}
assertIsAddress(value[0]);
}
var MAX_SEED_LENGTH = 32;
var MAX_SEEDS = 16;
var PDA_MARKER_BYTES = [
// The string 'ProgramDerivedAddress'
80,
114,
111,
103,
114,
97,
109,
68,
101,
114,
105,
118,
101,
100,
65,
100,
100,
114,
101,
115,
115
];
async function createProgramDerivedAddress({ programAddress, seeds }) {
(0,_solana_assertions__WEBPACK_IMPORTED_MODULE_3__/* .assertDigestCapabilityIsAvailable */ .cr)();
if (seeds.length > MAX_SEEDS) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED */ .R_T, {
actual: seeds.length,
maxSeeds: MAX_SEEDS
});
}
let textEncoder;
const seedBytes = seeds.reduce((acc, seed, ii) => {
const bytes = typeof seed === "string" ? (textEncoder ||= new TextEncoder()).encode(seed) : seed;
if (bytes.byteLength > MAX_SEED_LENGTH) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED */ .nNU, {
actual: bytes.byteLength,
index: ii,
maxSeedLength: MAX_SEED_LENGTH
});
}
acc.push(...bytes);
return acc;
}, []);
const base58EncodedAddressCodec = getAddressCodec();
const programAddressBytes = base58EncodedAddressCodec.encode(programAddress);
const addressBytesBuffer = await crypto.subtle.digest(
"SHA-256",
new Uint8Array([...seedBytes, ...programAddressBytes, ...PDA_MARKER_BYTES])
);
const addressBytes = new Uint8Array(addressBytesBuffer);
if (compressedPointBytesAreOnCurve(addressBytes)) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE */ .Ji6);
}
return base58EncodedAddressCodec.decode(addressBytes);
}
async function getProgramDerivedAddress({
programAddress,
seeds
}) {
let bumpSeed = 255;
while (bumpSeed > 0) {
try {
const address2 = await createProgramDerivedAddress({
programAddress,
seeds: [...seeds, new Uint8Array([bumpSeed])]
});
return [address2, bumpSeed];
} catch (e) {
if ((0,_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .isSolanaError */ .zbS)(e, _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE */ .Ji6)) {
bumpSeed--;
} else {
throw e;
}
}
}
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED */ .Y0g);
}
async function createAddressWithSeed({ baseAddress, programAddress, seed }) {
const { encode, decode } = getAddressCodec();
const seedBytes = typeof seed === "string" ? new TextEncoder().encode(seed) : seed;
if (seedBytes.byteLength > MAX_SEED_LENGTH) {
throw new SolanaError(SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED, {
actual: seedBytes.byteLength,
index: 0,
maxSeedLength: MAX_SEED_LENGTH
});
}
const programAddressBytes = encode(programAddress);
if (programAddressBytes.length >= PDA_MARKER_BYTES.length && bytesEqual(programAddressBytes.slice(-PDA_MARKER_BYTES.length), new Uint8Array(PDA_MARKER_BYTES))) {
throw new SolanaError(SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER);
}
const addressBytesBuffer = await crypto.subtle.digest(
"SHA-256",
new Uint8Array([...encode(baseAddress), ...seedBytes, ...programAddressBytes])
);
const addressBytes = new Uint8Array(addressBytesBuffer);
return decode(addressBytes);
}
async function getAddressFromPublicKey(publicKey) {
(0,_solana_assertions__WEBPACK_IMPORTED_MODULE_3__/* .assertKeyExporterIsAvailable */ .sw)();
if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_1__/* .SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY */ .xZX);
}
const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
}
async function getPublicKeyFromAddress(address2) {
const addressBytes = getAddressEncoder().encode(address2);
return await crypto.subtle.importKey("raw", addressBytes, { name: "Ed25519" }, true, ["verify"]);
}
//# sourceMappingURL=index.node.mjs.map
//# sourceMappingURL=index.node.mjs.map
/***/ }),
/***/ 40305:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ XF: () => (/* binding */ assertPRNGIsAvailable),
/* harmony export */ Zg: () => (/* binding */ assertVerificationCapabilityIsAvailable),
/* harmony export */ cr: () => (/* binding */ assertDigestCapabilityIsAvailable),
/* harmony export */ f_: () => (/* binding */ assertSigningCapabilityIsAvailable),
/* harmony export */ hT: () => (/* binding */ assertKeyGenerationIsAvailable),
/* harmony export */ sw: () => (/* binding */ assertKeyExporterIsAvailable)
/* harmony export */ });
/* harmony import */ var _solana_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13197);
// src/crypto.ts
function assertPRNGIsAvailable() {
if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.getRandomValues !== "function") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED */ .iOv);
}
}
var cachedEd25519Decision;
async function isEd25519CurveSupported(subtle) {
if (cachedEd25519Decision === void 0) {
cachedEd25519Decision = new Promise((resolve) => {
subtle.generateKey(
"Ed25519",
/* extractable */
false,
["sign", "verify"]
).then(() => {
resolve(cachedEd25519Decision = true);
}).catch(() => {
resolve(cachedEd25519Decision = false);
});
});
}
if (typeof cachedEd25519Decision === "boolean") {
return cachedEd25519Decision;
} else {
return await cachedEd25519Decision;
}
}
function assertDigestCapabilityIsAvailable() {
if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.digest !== "function") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED */ .JsK);
}
}
async function assertKeyGenerationIsAvailable() {
if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.generateKey !== "function") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED */ .Z5K);
}
if (!await isEd25519CurveSupported(globalThis.crypto.subtle)) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED */ .Izj);
}
}
function assertKeyExporterIsAvailable() {
if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__SUBTLE_CRYPTO__EXPORT_FUNCTION_UNIMPLEMENTED */ .kz9);
}
}
function assertSigningCapabilityIsAvailable() {
if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED */ .f$j);
}
}
function assertVerificationCapabilityIsAvailable() {
if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.verify !== "function") {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED */ .XzN);
}
}
//# sourceMappingURL=index.node.mjs.map
//# sourceMappingURL=index.node.mjs.map
/***/ }),
/***/ 32163:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ $C: () => (/* binding */ createDecoder),
/* harmony export */ Bq: () => (/* binding */ addEncoderSizePrefix),
/* harmony export */ C1: () => (/* binding */ assertByteArrayHasEnoughBytesForCodec),
/* harmony export */ FU: () => (/* binding */ transformEncoder),
/* harmony export */ Ns: () => (/* binding */ fixEncoderSize),
/* harmony export */ O6: () => (/* binding */ bytesEqual),
/* harmony export */ QM: () => (/* binding */ getEncodedSize),
/* harmony export */ Sc: () => (/* binding */ isFixedSize),
/* harmony export */ XA: () => (/* binding */ toArrayBuffer),
/* harmony export */ Xu: () => (/* binding */ fixCodecSize),
/* harmony export */ ex: () => (/* binding */ assertIsFixedSize),
/* harmony export */ mC: () => (/* binding */ combineCodec),
/* harmony export */ ng: () => (/* binding */ addCodecSizePrefix),
/* harmony export */ pI: () => (/* binding */ fixDecoderSize),
/* harmony export */ vt: () => (/* binding */ transformDecoder),
/* harmony export */ xB: () => (/* binding */ containsBytes),
/* harmony export */ xL: () => (/* binding */ assertByteArrayIsNotEmptyForCodec),
/* harmony export */ xv: () => (/* binding */ createEncoder)
/* harmony export */ });
/* unused harmony exports addCodecSentinel, addDecoderSentinel, addDecoderSizePrefix, addEncoderSentinel, assertByteArrayOffsetIsNotOutOfRange, assertIsVariableSize, createCodec, createDecoderThatConsumesEntireByteArray, fixBytes, isVariableSize, mergeBytes, offsetCodec, offsetDecoder, offsetEncoder, padBytes, padLeftCodec, padLeftDecoder, padLeftEncoder, padRightCodec, padRightDecoder, padRightEncoder, resizeCodec, resizeDecoder, resizeEncoder, reverseCodec, reverseDecoder, reverseEncoder, transformCodec */
/* harmony import */ var _solana_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13197);
// src/add-codec-sentinel.ts
// src/bytes.ts
var mergeBytes = (byteArrays) => {
const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);
if (nonEmptyByteArrays.length === 0) {
return byteArrays.length ? byteArrays[0] : new Uint8Array();
}
if (nonEmptyByteArrays.length === 1) {
return nonEmptyByteArrays[0];
}
const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);
const result = new Uint8Array(totalLength);
let offset = 0;
nonEmptyByteArrays.forEach((arr) => {
result.set(arr, offset);
offset += arr.length;
});
return result;
};
function padBytes(bytes, length) {
if (bytes.length >= length) return bytes;
const paddedBytes = new Uint8Array(length).fill(0);
paddedBytes.set(bytes);
return paddedBytes;
}
var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
function containsBytes(data, bytes, offset) {
const slice = offset === 0 && data.length === bytes.length ? data : data.slice(offset, offset + bytes.length);
return bytesEqual(slice, bytes);
}
function bytesEqual(bytes1, bytes2) {
return bytes1.length === bytes2.length && bytes1.every((value, index) => value === bytes2[index]);
}
function getEncodedSize(value, encoder) {
return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
}
function createEncoder(encoder) {
return Object.freeze({
...encoder,
encode: (value) => {
const bytes = new Uint8Array(getEncodedSize(value, encoder));
encoder.write(value, bytes, 0);
return bytes;
}
});
}
function createDecoder(decoder) {
return Object.freeze({
...decoder,
decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
});
}
function createCodec(codec) {
return Object.freeze({
...codec,
decode: (bytes, offset = 0) => codec.read(bytes, offset)[0],
encode: (value) => {
const bytes = new Uint8Array(getEncodedSize(value, codec));
codec.write(value, bytes, 0);
return bytes;
}
});
}
function isFixedSize(codec) {
return "fixedSize" in codec && typeof codec.fixedSize === "number";
}
function assertIsFixedSize(codec) {
if (!isFixedSize(codec)) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH */ .TY_);
}
}
function isVariableSize(codec) {
return !isFixedSize(codec);
}
function assertIsVariableSize(codec) {
if (!isVariableSize(codec)) {
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH);
}
}
function combineCodec(encoder, decoder) {
if (isFixedSize(encoder) !== isFixedSize(decoder)) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH */ .CvZ);
}
if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH */ .Uq4, {
decoderFixedSize: decoder.fixedSize,
encoderFixedSize: encoder.fixedSize
});
}
if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH */ .SHY, {
decoderMaxSize: decoder.maxSize,
encoderMaxSize: encoder.maxSize
});
}
return {
...decoder,
...encoder,
decode: decoder.decode,
encode: encoder.encode,
read: decoder.read,
write: encoder.write
};
}
// src/add-codec-sentinel.ts
function addEncoderSentinel(encoder, sentinel) {
const write = ((value, bytes, offset) => {
const encoderBytes = encoder.encode(value);
if (findSentinelIndex(encoderBytes, sentinel) >= 0) {
throw new SolanaError(SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL, {
encodedBytes: encoderBytes,
hexEncodedBytes: hexBytes(encoderBytes),
hexSentinel: hexBytes(sentinel),
sentinel
});
}
bytes.set(encoderBytes, offset);
offset += encoderBytes.length;
bytes.set(sentinel, offset);
offset += sentinel.length;
return offset;
});
if (isFixedSize(encoder)) {
return createEncoder({ ...encoder, fixedSize: encoder.fixedSize + sentinel.length, write });
}
return createEncoder({
...encoder,
...encoder.maxSize != null ? { maxSize: encoder.maxSize + sentinel.length } : {},
getSizeFromValue: (value) => encoder.getSizeFromValue(value) + sentinel.length,
write
});
}
function addDecoderSentinel(decoder, sentinel) {
const read = ((bytes, offset) => {
const candidateBytes = offset === 0 ? bytes : bytes.slice(offset);
const sentinelIndex = findSentinelIndex(candidateBytes, sentinel);
if (sentinelIndex === -1) {
throw new SolanaError(SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES, {
decodedBytes: candidateBytes,
hexDecodedBytes: hexBytes(candidateBytes),
hexSentinel: hexBytes(sentinel),
sentinel
});
}
const preSentinelBytes = candidateBytes.slice(0, sentinelIndex);
return [decoder.decode(preSentinelBytes), offset + preSentinelBytes.length + sentinel.length];
});
if (isFixedSize(decoder)) {
return createDecoder({ ...decoder, fixedSize: decoder.fixedSize + sentinel.length, read });
}
return createDecoder({
...decoder,
...decoder.maxSize != null ? { maxSize: decoder.maxSize + sentinel.length } : {},
read
});
}
function addCodecSentinel(codec, sentinel) {
return combineCodec(addEncoderSentinel(codec, sentinel), addDecoderSentinel(codec, sentinel));
}
function findSentinelIndex(bytes, sentinel) {
return bytes.findIndex((byte, index, arr) => {
if (sentinel.length === 1) return byte === sentinel[0];
return containsBytes(arr, sentinel, index);
});
}
function hexBytes(bytes) {
return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
}
function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
if (bytes.length - offset <= 0) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY */ .Ot7, {
codecDescription
});
}
}
function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
const bytesLength = bytes.length - offset;
if (bytesLength < expected) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH */ .Uyo, {
bytesLength,
codecDescription,
expected
});
}
}
function assertByteArrayOffsetIsNotOutOfRange(codecDescription, offset, bytesLength) {
if (offset < 0 || offset > bytesLength) {
throw new SolanaError(SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE, {
bytesLength,
codecDescription,
offset
});
}
}
// src/add-codec-size-prefix.ts
function addEncoderSizePrefix(encoder, prefix) {
const write = ((value, bytes, offset) => {
const encoderBytes = encoder.encode(value);
offset = prefix.write(encoderBytes.length, bytes, offset);
bytes.set(encoderBytes, offset);
return offset + encoderBytes.length;
});
if (isFixedSize(prefix) && isFixedSize(encoder)) {
return createEncoder({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
}
const prefixMaxSize = isFixedSize(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
const encoderMaxSize = isFixedSize(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
return createEncoder({
...encoder,
...maxSize !== null ? { maxSize } : {},
getSizeFromValue: (value) => {
const encoderSize = getEncodedSize(value, encoder);
return getEncodedSize(encoderSize, prefix) + encoderSize;
},
write
});
}
function addDecoderSizePrefix(decoder, prefix) {
const read = ((bytes, offset) => {
const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
const size = Number(bigintSize);
offset = decoderOffset;
if (offset > 0 || bytes.length > size) {
bytes = bytes.slice(offset, offset + size);
}
assertByteArrayHasEnoughBytesForCodec("addDecoderSizePrefix", size, bytes);
return [decoder.decode(bytes), offset + size];
});
if (isFixedSize(prefix) && isFixedSize(decoder)) {
return createDecoder({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
}
const prefixMaxSize = isFixedSize(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
const decoderMaxSize = isFixedSize(decoder) ? decoder.fixedSize : decoder.maxSize ?? null;
const maxSize = prefixMaxSize !== null && decoderMaxSize !== null ? prefixMaxSize + decoderMaxSize : null;
return createDecoder({ ...decoder, ...maxSize !== null ? { maxSize } : {}, read });
}
function addCodecSizePrefix(codec, prefix) {
return combineCodec(addEncoderSizePrefix(codec, prefix), addDecoderSizePrefix(codec, prefix));
}
// src/array-buffers.ts
function toArrayBuffer(bytes, offset, length) {
const bytesOffset = bytes.byteOffset + (offset ?? 0);
const bytesLength = length ?? bytes.byteLength;
let buffer;
if (typeof SharedArrayBuffer === "undefined") {
buffer = bytes.buffer;
} else if (bytes.buffer instanceof SharedArrayBuffer) {
buffer = new ArrayBuffer(bytes.length);
new Uint8Array(buffer).set(new Uint8Array(bytes));
} else {
buffer = bytes.buffer;
}
return (bytesOffset === 0 || bytesOffset === -bytes.byteLength) && bytesLength === bytes.byteLength ? buffer : buffer.slice(bytesOffset, bytesOffset + bytesLength);
}
function createDecoderThatConsumesEntireByteArray(decoder) {
return createDecoder({
...decoder,
read(bytes, offset) {
const [value, newOffset] = decoder.read(bytes, offset);
if (bytes.length > newOffset) {
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_DECODER_TO_CONSUME_ENTIRE_BYTE_ARRAY, {
expectedLength: newOffset,
numExcessBytes: bytes.length - newOffset
});
}
return [value, newOffset];
}
});
}
// src/fix-codec-size.ts
function fixEncoderSize(encoder, fixedBytes) {
return createEncoder({
fixedSize: fixedBytes,
write: (value, bytes, offset) => {
const variableByteArray = encoder.encode(value);
const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
bytes.set(fixedByteArray, offset);
return offset + fixedBytes;
}
});
}
function fixDecoderSize(decoder, fixedBytes) {
return createDecoder({
fixedSize: fixedBytes,
read: (bytes, offset) => {
assertByteArrayHasEnoughBytesForCodec("fixCodecSize", fixedBytes, bytes, offset);
if (offset > 0 || bytes.length > fixedBytes) {
bytes = bytes.slice(offset, offset + fixedBytes);
}
if (isFixedSize(decoder)) {
bytes = fixBytes(bytes, decoder.fixedSize);
}
const [value] = decoder.read(bytes, 0);
return [value, offset + fixedBytes];
}
});
}
function fixCodecSize(codec, fixedBytes) {
return combineCodec(fixEncoderSize(codec, fixedBytes), fixDecoderSize(codec, fixedBytes));
}
// src/offset-codec.ts
function offsetEncoder(encoder, config) {
return createEncoder({
...encoder,
write: (value, bytes, preOffset) => {
const wrapBytes = (offset) => modulo(offset, bytes.length);
const newPreOffset = config.preOffset ? config.preOffset({ bytes, preOffset, wrapBytes }) : preOffset;
assertByteArrayOffsetIsNotOutOfRange("offsetEncoder", newPreOffset, bytes.length);
const postOffset = encoder.write(value, bytes, newPreOffset);
const newPostOffset = config.postOffset ? config.postOffset({ bytes, newPreOffset, postOffset, preOffset, wrapBytes }) : postOffset;
assertByteArrayOffsetIsNotOutOfRange("offsetEncoder", newPostOffset, bytes.length);
return newPostOffset;
}
});
}
function offsetDecoder(decoder, config) {
return createDecoder({
...decoder,
read: (bytes, preOffset) => {
const wrapBytes = (offset) => modulo(offset, bytes.length);
const newPreOffset = config.preOffset ? config.preOffset({ bytes, preOffset, wrapBytes }) : preOffset;
assertByteArrayOffsetIsNotOutOfRange("offsetDecoder", newPreOffset, bytes.length);
const [value, postOffset] = decoder.read(bytes, newPreOffset);
const newPostOffset = config.postOffset ? config.postOffset({ bytes, newPreOffset, postOffset, preOffset, wrapBytes }) : postOffset;
assertByteArrayOffsetIsNotOutOfRange("offsetDecoder", newPostOffset, bytes.length);
return [value, newPostOffset];
}
});
}
function offsetCodec(codec, config) {
return combineCodec(offsetEncoder(codec, config), offsetDecoder(codec, config));
}
function modulo(dividend, divisor) {
if (divisor === 0) return 0;
return (dividend % divisor + divisor) % divisor;
}
function resizeEncoder(encoder, resize) {
if (isFixedSize(encoder)) {
const fixedSize = resize(encoder.fixedSize);
if (fixedSize < 0) {
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
bytesLength: fixedSize,
codecDescription: "resizeEncoder"
});
}
return createEncoder({ ...encoder, fixedSize });
}
return createEncoder({
...encoder,
getSizeFromValue: (value) => {
const newSize = resize(encoder.getSizeFromValue(value));
if (newSize < 0) {
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
bytesLength: newSize,
codecDescription: "resizeEncoder"
});
}
return newSize;
}
});
}
function resizeDecoder(decoder, resize) {
if (isFixedSize(decoder)) {
const fixedSize = resize(decoder.fixedSize);
if (fixedSize < 0) {
throw new SolanaError(SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH, {
bytesLength: fixedSize,
codecDescription: "resizeDecoder"
});
}
return createDecoder({ ...decoder, fixedSize });
}
return decoder;
}
function resizeCodec(codec, resize) {
return combineCodec(resizeEncoder(codec, resize), resizeDecoder(codec, resize));
}
// src/pad-codec.ts
function padLeftEncoder(encoder, offset) {
return offsetEncoder(
resizeEncoder(encoder, (size) => size + offset),
{ preOffset: ({ preOffset }) => preOffset + offset }
);
}
function padRightEncoder(encoder, offset) {
return offsetEncoder(
resizeEncoder(encoder, (size) => size + offset),
{ postOffset: ({ postOffset }) => postOffset + offset }
);
}
function padLeftDecoder(decoder, offset) {
return offsetDecoder(
resizeDecoder(decoder, (size) => size + offset),
{ preOffset: ({ preOffset }) => preOffset + offset }
);
}
function padRightDecoder(decoder, offset) {
return offsetDecoder(
resizeDecoder(decoder, (size) => size + offset),
{ postOffset: ({ postOffset }) => postOffset + offset }
);
}
function padLeftCodec(codec, offset) {
return combineCodec(padLeftEncoder(codec, offset), padLeftDecoder(codec, offset));
}
function padRightCodec(codec, offset) {
return combineCodec(padRightEncoder(codec, offset), padRightDecoder(codec, offset));
}
// src/reverse-codec.ts
function copySourceToTargetInReverse(source, target_WILL_MUTATE, sourceOffset, sourceLength, targetOffset = 0) {
while (sourceOffset < --sourceLength) {
const leftValue = source[sourceOffset];
target_WILL_MUTATE[sourceOffset + targetOffset] = source[sourceLength];
target_WILL_MUTATE[sourceLength + targetOffset] = leftValue;
sourceOffset++;
}
if (sourceOffset === sourceLength) {
target_WILL_MUTATE[sourceOffset + targetOffset] = source[sourceOffset];
}
}
function reverseEncoder(encoder) {
assertIsFixedSize(encoder);
return createEncoder({
...encoder,
write: (value, bytes, offset) => {
const newOffset = encoder.write(value, bytes, offset);
copySourceToTargetInReverse(
bytes,
bytes,
offset,
offset + encoder.fixedSize
);
return newOffset;
}
});
}
function reverseDecoder(decoder) {
assertIsFixedSize(decoder);
return createDecoder({
...decoder,
read: (bytes, offset) => {
const reversedBytes = bytes.slice();
copySourceToTargetInReverse(
bytes,
reversedBytes,
offset,
offset + decoder.fixedSize
);
return decoder.read(reversedBytes, offset);
}
});
}
function reverseCodec(codec) {
return combineCodec(reverseEncoder(codec), reverseDecoder(codec));
}
// src/transform-codec.ts
function transformEncoder(encoder, unmap) {
return createEncoder({
...isVariableSize(encoder) ? { ...encoder, getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value)) } : encoder,
write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
});
}
function transformDecoder(decoder, map) {
return createDecoder({
...decoder,
read: (bytes, offset) => {
const [value, newOffset] = decoder.read(bytes, offset);
return [map(value, bytes, offset), newOffset];
}
});
}
function transformCodec(codec, unmap, map) {
return createCodec({
...transformEncoder(codec, unmap),
read: map ? transformDecoder(codec, map).read : codec.read
});
}
//# sourceMappingURL=index.node.mjs.map
//# sourceMappingURL=index.node.mjs.map
/***/ }),
/***/ 12473:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ ED: () => (/* binding */ getBytesCodec),
/* harmony export */ Ey: () => (/* binding */ getNullableEncoder),
/* harmony export */ Im: () => (/* binding */ getBytesEncoder),
/* harmony export */ J8: () => (/* binding */ getConstantEncoder),
/* harmony export */ M2: () => (/* binding */ getNullableDecoder),
/* harmony export */ O_: () => (/* binding */ getArrayDecoder),
/* harmony export */ a5: () => (/* binding */ getStructEncoder),
/* harmony export */ ci: () => (/* binding */ getStructDecoder),
/* harmony export */ is: () => (/* binding */ getArrayEncoder),
/* harmony export */ md: () => (/* binding */ getUnionEncoder),
/* harmony export */ qs: () => (/* binding */ getPredicateEncoder),
/* harmony export */ rv: () => (/* binding */ getBooleanCodec),
/* harmony export */ yu: () => (/* binding */ getNullableCodec)
/* harmony export */ });
/* unused harmony exports assertValidNumberOfItemsForCodec, getArrayCodec, getBitArrayCodec, getBitArrayDecoder, getBitArrayEncoder, getBooleanDecoder, getBooleanEncoder, getBytesDecoder, getConstantCodec, getConstantDecoder, getDiscriminatedUnionCodec, getDiscriminatedUnionDecoder, getDiscriminatedUnionEncoder, getEnumCodec, getEnumDecoder, getEnumEncoder, getHiddenPrefixCodec, getHiddenPrefixDecoder, getHiddenPrefixEncoder, getHiddenSuffixCodec, getHiddenSuffixDecoder, getHiddenSuffixEncoder, getLiteralUnionCodec, getLiteralUnionDecoder, getLiteralUnionEncoder, getMapCodec, getMapDecoder, getMapEncoder, getPredicateCodec, getPredicateDecoder, getSetCodec, getSetDecoder, getSetEncoder, getStructCodec, getTupleCodec, getTupleDecoder, getTupleEncoder, getUnionCodec, getUnionDecoder, getUnitCodec, getUnitDecoder, getUnitEncoder */
/* harmony import */ var _solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(32163);
/* harmony import */ var _solana_codecs_numbers__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(17991);
/* harmony import */ var _solana_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13197);
// src/array.ts
function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
if (expected !== actual) {
throw new _solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SolanaError */ .tsw(_solana_errors__WEBPACK_IMPORTED_MODULE_0__/* .SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS */ .lUj, {
actual,
codecDescription,
expected
});
}
}
function maxCodecSizes(sizes) {
return sizes.reduce(
(all, size) => all === null || size === null ? null : Math.max(all, size),
0
);
}
function sumCodecSizes(sizes) {
return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
}
function getFixedSize(codec) {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .isFixedSize */ .Sc)(codec) ? codec.fixedSize : null;
}
function getMaxSize(codec) {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .isFixedSize */ .Sc)(codec) ? codec.fixedSize : codec.maxSize ?? null;
}
// src/array.ts
function getArrayEncoder(item, config = {}) {
const size = config.size ?? (0,_solana_codecs_numbers__WEBPACK_IMPORTED_MODULE_2__/* .getU32Encoder */ .PL)();
const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .createEncoder */ .xv)({
...fixedSize !== null ? { fixedSize } : {
getSizeFromValue: (array) => {
const prefixSize = typeof size === "object" ? (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .getEncodedSize */ .QM)(array.length, size) : 0;
return prefixSize + [...array].reduce((all, value) => all + (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .getEncodedSize */ .QM)(value, item), 0);
},
maxSize
},
write: (array, bytes, offset) => {
if (typeof size === "number") {
assertValidNumberOfItemsForCodec(config.description ?? "array", size, array.length);
}
if (typeof size === "object") {
offset = size.write(array.length, bytes, offset);
}
array.forEach((value) => {
offset = item.write(value, bytes, offset);
});
return offset;
}
});
}
function getArrayDecoder(item, config = {}) {
const size = config.size ?? (0,_solana_codecs_numbers__WEBPACK_IMPORTED_MODULE_2__/* .getU32Decoder */ .VI)();
const itemSize = getFixedSize(item);
const fixedSize = computeArrayLikeCodecSize(size, itemSize);
const maxSize = computeArrayLikeCodecSize(size, getMaxSize(item)) ?? void 0;
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .createDecoder */ .$C)({
...fixedSize !== null ? { fixedSize } : { maxSize },
read: (bytes, offset) => {
const array = [];
if (typeof size === "object" && bytes.slice(offset).length === 0) {
return [array, offset];
}
if (size === "remainder") {
while (offset < bytes.length) {
const [value, newOffset2] = item.read(bytes, offset);
offset = newOffset2;
array.push(value);
}
return [array, offset];
}
const [resolvedSize, newOffset] = typeof size === "number" ? [size, offset] : size.read(bytes, offset);
offset = newOffset;
for (let i = 0; i < resolvedSize; i += 1) {
const [value, newOffset2] = item.read(bytes, offset);
offset = newOffset2;
array.push(value);
}
return [array, offset];
}
});
}
function getArrayCodec(item, config = {}) {
return combineCodec(getArrayEncoder(item, config), getArrayDecoder(item, config));
}
function computeArrayLikeCodecSize(size, itemSize) {
if (typeof size !== "number") return null;
if (size === 0) return 0;
return itemSize === null ? null : itemSize * size;
}
function getBitArrayEncoder(size, config = {}) {
const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
const backward = parsedConfig.backward ?? false;
return createEncoder({
fixedSize: size,
write(value, bytes, offset) {
const bytesToAdd = [];
for (let i = 0; i < size; i += 1) {
let byte = 0;
for (let j = 0; j < 8; j += 1) {
const feature = Number(value[i * 8 + j] ?? 0);
byte |= feature << (backward ? j : 7 - j);
}
if (backward) {
bytesToAdd.unshift(byte);
} else {
bytesToAdd.push(byte);
}
}
bytes.set(bytesToAdd, offset);
return size;
}
});
}
function getBitArrayDecoder(size, config = {}) {
const parsedConfig = typeof config === "boolean" ? { backward: config } : config;
const backward = parsedConfig.backward ?? false;
return createDecoder({
fixedSize: size,
read(bytes, offset) {
assertByteArrayHasEnoughBytesForCodec("bitArray", size, bytes, offset);
const booleans = [];
let slice = bytes.slice(offset, offset + size);
slice = backward ? slice.reverse() : slice;
slice.forEach((byte) => {
for (let i = 0; i < 8; i += 1) {
if (backward) {
booleans.push(Boolean(byte & 1));
byte >>= 1;
} else {
booleans.push(Boolean(byte & 128));
byte <<= 1;
}
}
});
return [booleans, offset + size];
}
});
}
function getBitArrayCodec(size, config = {}) {
return combineCodec(getBitArrayEncoder(size, config), getBitArrayDecoder(size, config));
}
function getBooleanEncoder(config = {}) {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .transformEncoder */ .FU)(config.size ?? (0,_solana_codecs_numbers__WEBPACK_IMPORTED_MODULE_2__/* .getU8Encoder */ .Qe)(), (value) => value ? 1 : 0);
}
function getBooleanDecoder(config = {}) {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .transformDecoder */ .vt)(config.size ?? (0,_solana_codecs_numbers__WEBPACK_IMPORTED_MODULE_2__/* .getU8Decoder */ .eh)(), (value) => Number(value) === 1);
}
function getBooleanCodec(config = {}) {
return (0,_solana_codecs_core__WEBPACK_IMPORTED_MODULE_1__/* .combineCodec */ .mC)(getBooleanEncoder(config), getBooleanDecoder(config));
}
function getBytesEnco