@solana/accounts 2.0.0-experimental.1db8859

package/dist/index.development.js

@@ -0,0 +1,179 @@
+this.globalThis = this.globalThis || {};
+this.globalThis.solanaWeb3 = (function (exports) {
+  'use strict';
+
+  // src/account.ts
+  var BASE_ACCOUNT_SIZE = 128;
+
+  // src/decode-account.ts
+  function decodeAccount(encodedAccount, decoder) {
+    try {
+      if ("exists" in encodedAccount && !encodedAccount.exists) {
+        return encodedAccount;
+      }
+      return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
+    } catch (error) {
+      const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);
+      newError.cause = error;
+      throw newError;
+    }
+  }
+
+  // ../codecs-core/dist/index.browser.js
+  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;
+      }
+    });
+  }
+
+  // ../codecs-strings/dist/index.browser.js
+  function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+    if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
+      throw new Error(`Expected a string of base ${alphabet4.length}, got [${givenValue}].`);
+    }
+  }
+  var getBaseXEncoder = (alphabet4) => {
+    return createEncoder({
+      getSizeFromValue: (value) => {
+        const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+        if (tailChars === "")
+          return value.length;
+        const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+        return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+      },
+      write(value, bytes, offset) {
+        assertValidBaseString(alphabet4, value);
+        if (value === "")
+          return offset;
+        const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+        if (tailChars === "") {
+          bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+          return offset + leadingZeroes.length;
+        }
+        let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+        const tailBytes = [];
+        while (base10Number > 0n) {
+          tailBytes.unshift(Number(base10Number % 256n));
+          base10Number /= 256n;
+        }
+        const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+        bytes.set(bytesToAdd, offset);
+        return offset + bytesToAdd.length;
+      }
+    });
+  };
+  function partitionLeadingZeroes(value, zeroCharacter) {
+    const leadingZeroIndex = [...value].findIndex((c) => c !== zeroCharacter);
+    return leadingZeroIndex === -1 ? [value, ""] : [value.slice(0, leadingZeroIndex), value.slice(leadingZeroIndex)];
+  }
+  function getBigIntFromBaseX(value, alphabet4) {
+    const base = BigInt(alphabet4.length);
+    return [...value].reduce((sum, char) => sum * base + BigInt(alphabet4.indexOf(char)), 0n);
+  }
+  var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+  var getBase64Encoder = () => {
+    {
+      return createEncoder({
+        getSizeFromValue: (value) => {
+          try {
+            return atob(value).length;
+          } catch (e2) {
+            throw new Error(`Expected a string of base 64, got [${value}].`);
+          }
+        },
+        write(value, bytes, offset) {
+          try {
+            const bytesToAdd = atob(value).split("").map((c) => c.charCodeAt(0));
+            bytes.set(bytesToAdd, offset);
+            return bytesToAdd.length + offset;
+          } catch (e2) {
+            throw new Error(`Expected a string of base 64, got [${value}].`);
+          }
+        }
+      });
+    }
+  };
+
+  // src/parse-account.ts
+  function parseBase64RpcAccount(address, rpcAccount) {
+    if (!rpcAccount)
+      return Object.freeze({ address, exists: false });
+    const data = getBase64Encoder().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;
+    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
+  }
+  function parseBaseAccount(rpcAccount) {
+    return Object.freeze({
+      executable: rpcAccount.executable,
+      lamports: rpcAccount.lamports,
+      programAddress: rpcAccount.owner
+    });
+  }
+
+  // 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);
+    });
+  }
+
+  // src/maybe-account.ts
+  function assertAccountExists(account) {
+    if (!account.exists) {
+      throw new Error(`Expected account [${account.address}] to exist.`);
+    }
+  }
+
+  exports.BASE_ACCOUNT_SIZE = BASE_ACCOUNT_SIZE;
+  exports.assertAccountExists = assertAccountExists;
+  exports.decodeAccount = decodeAccount;
+  exports.fetchEncodedAccount = fetchEncodedAccount;
+  exports.fetchEncodedAccounts = fetchEncodedAccounts;
+  exports.fetchJsonParsedAccount = fetchJsonParsedAccount;
+  exports.fetchJsonParsedAccounts = fetchJsonParsedAccounts;
+  exports.parseBase58RpcAccount = parseBase58RpcAccount;
+  exports.parseBase64RpcAccount = parseBase64RpcAccount;
+  exports.parseJsonRpcAccount = parseJsonRpcAccount;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.development.js.map

package/dist/index.development.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/account.ts","../src/decode-account.ts","../../codecs-core/src/codec.ts","../../codecs-strings/src/assertions.ts","../../codecs-strings/src/baseX.ts","../../codecs-strings/src/base16.ts","../../codecs-strings/src/baseX-reslice.ts","../../codecs-strings/src/base64.ts","../src/parse-account.ts","../src/fetch-account.ts","../src/maybe-account.ts"],"names":["alphabet"],"mappings":"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","sourcesContent":["import type { Address } from '@solana/addresses';\nimport type { LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';\n\n/** The amount of bytes required to store the base account information without its data. */\nexport const BASE_ACCOUNT_SIZE = 128;\n\n/** Describe the generic account details applicable to every account. */\nexport type BaseAccount = {\n    readonly programAddress: Address;\n    readonly executable: boolean;\n    readonly lamports: LamportsUnsafeBeyond2Pow53Minus1;\n};\n\n/** Defines a Solana account with its generic details and parsed or encoded data. */\nexport type Account<TData extends object | Uint8Array, TAddress extends string = string> = BaseAccount & {\n    readonly address: Address<TAddress>;\n    readonly data: TData;\n};\n\n/** Defines a Solana account with its generic details and encoded data. */\nexport type EncodedAccount<TAddress extends string = string> = Account<Uint8Array, TAddress>;\n","import type { Decoder } from '@solana/codecs-core';\n\nimport type { Account, EncodedAccount } from './account';\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\n/** Decodes the data of a given account using the provided decoder. */\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): MaybeAccount<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    try {\n        if ('exists' in encodedAccount && !encodedAccount.exists) {\n            return encodedAccount;\n        }\n        return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });\n    } catch (error) {\n        // TODO: Coded error.\n        const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);\n        newError.cause = error;\n        throw newError;\n    }\n}\n","/**\n * Defines an offset in bytes.\n */\nexport type Offset = number;\n\ntype BaseEncoder<TFrom> = {\n    /** Encode the provided value and return the encoded bytes directly. */\n    readonly encode: (value: TFrom) => Uint8Array;\n    /**\n     * Writes the encoded value into the provided byte array at the given offset.\n     * Returns the offset of the next byte after the encoded value.\n     */\n    readonly write: (value: TFrom, bytes: Uint8Array, offset: Offset) => Offset;\n};\n\nexport type FixedSizeEncoder<TFrom, TSize extends number = number> = BaseEncoder<TFrom> & {\n    /** The fixed size of the encoded value in bytes. */\n    readonly fixedSize: TSize;\n};\n\nexport type VariableSizeEncoder<TFrom> = BaseEncoder<TFrom> & {\n    /** The total size of the encoded value in bytes. */\n    readonly getSizeFromValue: (value: TFrom) => number;\n    /** The maximum size an encoded value can be in bytes, if applicable. */\n    readonly maxSize?: number;\n};\n\n/**\n * An object that can encode a value to a `Uint8Array`.\n */\nexport type Encoder<TFrom> = FixedSizeEncoder<TFrom> | VariableSizeEncoder<TFrom>;\n\ntype BaseDecoder<TTo> = {\n    /** Decodes the provided byte array at the given offset (or zero) and returns the value directly. */\n    readonly decode: (bytes: Uint8Array, offset?: Offset) => TTo;\n    /**\n     * Reads the encoded value from the provided byte array at the given offset.\n     * Returns the decoded value and the offset of the next byte after the encoded value.\n     */\n    readonly read: (bytes: Uint8Array, offset: Offset) => [TTo, Offset];\n};\n\nexport type FixedSizeDecoder<TTo, TSize extends number = number> = BaseDecoder<TTo> & {\n    /** The fixed size of the encoded value in bytes. */\n    readonly fixedSize: TSize;\n};\n\nexport type VariableSizeDecoder<TTo> = BaseDecoder<TTo> & {\n    /** The maximum size an encoded value can be in bytes, if applicable. */\n    readonly maxSize?: number;\n};\n\n/**\n * An object that can decode a value from a `Uint8Array`.\n */\nexport type Decoder<TTo> = FixedSizeDecoder<TTo> | VariableSizeDecoder<TTo>;\n\nexport type FixedSizeCodec<TFrom, TTo extends TFrom = TFrom, TSize extends number = number> = FixedSizeEncoder<\n    TFrom,\n    TSize\n> &\n    FixedSizeDecoder<TTo, TSize>;\n\nexport type VariableSizeCodec<TFrom, TTo extends TFrom = TFrom> = VariableSizeEncoder<TFrom> & VariableSizeDecoder<TTo>;\n\n/**\n * An object that can encode and decode a value to and from a `Uint8Array`.\n * It supports encoding looser types than it decodes for convenience.\n * For example, a `bigint` encoder will always decode to a `bigint`\n * but can be used to encode a `number`.\n *\n * @typeParam TFrom - The type of the value to encode.\n * @typeParam TTo - The type of the decoded value. Defaults to `TFrom`.\n */\nexport type Codec<TFrom, TTo extends TFrom = TFrom> = FixedSizeCodec<TFrom, TTo> | VariableSizeCodec<TFrom, TTo>;\n\n/**\n * Get the encoded size of a given value in bytes.\n */\nexport function getEncodedSize<TFrom>(\n    value: TFrom,\n    encoder: { fixedSize: number } | { getSizeFromValue: (value: TFrom) => number },\n): number {\n    return 'fixedSize' in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);\n}\n\n/** Fills the missing `encode` function using the existing `write` function. */\nexport function createEncoder<TFrom, TSize extends number>(\n    encoder: Omit<FixedSizeEncoder<TFrom, TSize>, 'encode'>,\n): FixedSizeEncoder<TFrom, TSize>;\nexport function createEncoder<TFrom>(encoder: Omit<VariableSizeEncoder<TFrom>, 'encode'>): VariableSizeEncoder<TFrom>;\nexport function createEncoder<TFrom>(\n    encoder: Omit<FixedSizeEncoder<TFrom>, 'encode'> | Omit<VariableSizeEncoder<TFrom>, 'encode'>,\n): Encoder<TFrom>;\nexport function createEncoder<TFrom>(\n    encoder: Omit<FixedSizeEncoder<TFrom>, 'encode'> | Omit<VariableSizeEncoder<TFrom>, 'encode'>,\n): Encoder<TFrom> {\n    return Object.freeze({\n        ...encoder,\n        encode: value => {\n            const bytes = new Uint8Array(getEncodedSize(value, encoder));\n            encoder.write(value, bytes, 0);\n            return bytes;\n        },\n    });\n}\n\n/** Fills the missing `decode` function using the existing `read` function. */\nexport function createDecoder<TTo, TSize extends number>(\n    decoder: Omit<FixedSizeDecoder<TTo, TSize>, 'decode'>,\n): FixedSizeDecoder<TTo, TSize>;\nexport function createDecoder<TTo>(decoder: Omit<VariableSizeDecoder<TTo>, 'decode'>): VariableSizeDecoder<TTo>;\nexport function createDecoder<TTo>(\n    decoder: Omit<FixedSizeDecoder<TTo>, 'decode'> | Omit<VariableSizeDecoder<TTo>, 'decode'>,\n): Decoder<TTo>;\nexport function createDecoder<TTo>(\n    decoder: Omit<FixedSizeDecoder<TTo>, 'decode'> | Omit<VariableSizeDecoder<TTo>, 'decode'>,\n): Decoder<TTo> {\n    return Object.freeze({\n        ...decoder,\n        decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0],\n    });\n}\n\n/** Fills the missing `encode` and `decode` function using the existing `write` and `read` functions. */\nexport function createCodec<TFrom, TTo extends TFrom = TFrom, TSize extends number = number>(\n    codec: Omit<FixedSizeCodec<TFrom, TTo, TSize>, 'encode' | 'decode'>,\n): FixedSizeCodec<TFrom, TTo, TSize>;\nexport function createCodec<TFrom, TTo extends TFrom = TFrom>(\n    codec: Omit<VariableSizeCodec<TFrom, TTo>, 'encode' | 'decode'>,\n): VariableSizeCodec<TFrom, TTo>;\nexport function createCodec<TFrom, TTo extends TFrom = TFrom>(\n    codec:\n        | Omit<FixedSizeCodec<TFrom, TTo>, 'encode' | 'decode'>\n        | Omit<VariableSizeCodec<TFrom, TTo>, 'encode' | 'decode'>,\n): Codec<TFrom, TTo>;\nexport function createCodec<TFrom, TTo extends TFrom = TFrom>(\n    codec:\n        | Omit<FixedSizeCodec<TFrom, TTo>, 'encode' | 'decode'>\n        | Omit<VariableSizeCodec<TFrom, TTo>, 'encode' | 'decode'>,\n): Codec<TFrom, TTo> {\n    return Object.freeze({\n        ...codec,\n        decode: (bytes, offset = 0) => codec.read(bytes, offset)[0],\n        encode: value => {\n            const bytes = new Uint8Array(getEncodedSize(value, codec));\n            codec.write(value, bytes, 0);\n            return bytes;\n        },\n    });\n}\n\nexport function isFixedSize<TFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TFrom, TSize> | VariableSizeEncoder<TFrom>,\n): encoder is FixedSizeEncoder<TFrom, TSize>;\nexport function isFixedSize<TTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TTo, TSize> | VariableSizeDecoder<TTo>,\n): decoder is FixedSizeDecoder<TTo, TSize>;\nexport function isFixedSize<TFrom, TTo extends TFrom, TSize extends number>(\n    codec: FixedSizeCodec<TFrom, TTo, TSize> | VariableSizeCodec<TFrom, TTo>,\n): codec is FixedSizeCodec<TFrom, TTo, TSize>;\nexport function isFixedSize<TSize extends number>(\n    codec: { fixedSize: TSize } | { maxSize?: number },\n): codec is { fixedSize: TSize };\nexport function isFixedSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { fixedSize: number } {\n    return 'fixedSize' in codec && typeof codec.fixedSize === 'number';\n}\n\nexport function assertIsFixedSize<TFrom, TSize extends number>(\n    encoder: FixedSizeEncoder<TFrom, TSize> | VariableSizeEncoder<TFrom>,\n    message?: string,\n): asserts encoder is FixedSizeEncoder<TFrom, TSize>;\nexport function assertIsFixedSize<TTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TTo, TSize> | VariableSizeDecoder<TTo>,\n    message?: string,\n): asserts decoder is FixedSizeDecoder<TTo, TSize>;\nexport function assertIsFixedSize<TFrom, TTo extends TFrom, TSize extends number>(\n    codec: FixedSizeCodec<TFrom, TTo, TSize> | VariableSizeCodec<TFrom, TTo>,\n    message?: string,\n): asserts codec is FixedSizeCodec<TFrom, TTo, TSize>;\nexport function assertIsFixedSize<TSize extends number>(\n    codec: { fixedSize: TSize } | { maxSize?: number },\n    message?: string,\n): asserts codec is { fixedSize: TSize };\nexport function assertIsFixedSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n    message?: string,\n): asserts codec is { fixedSize: number } {\n    if (!isFixedSize(codec)) {\n        // TODO: Coded error.\n        throw new Error(message ?? 'Expected a fixed-size codec, got a variable-size one.');\n    }\n}\n\nexport function isVariableSize<TFrom>(encoder: Encoder<TFrom>): encoder is VariableSizeEncoder<TFrom>;\nexport function isVariableSize<TTo>(decoder: Decoder<TTo>): decoder is VariableSizeDecoder<TTo>;\nexport function isVariableSize<TFrom, TTo extends TFrom>(\n    codec: Codec<TFrom, TTo>,\n): codec is VariableSizeCodec<TFrom, TTo>;\nexport function isVariableSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { maxSize?: number };\nexport function isVariableSize(codec: { fixedSize: number } | { maxSize?: number }): codec is { maxSize?: number } {\n    return !isFixedSize(codec);\n}\n\nexport function assertIsVariableSize<T>(\n    encoder: Encoder<T>,\n    message?: string,\n): asserts encoder is VariableSizeEncoder<T>;\nexport function assertIsVariableSize<T>(\n    decoder: Decoder<T>,\n    message?: string,\n): asserts decoder is VariableSizeDecoder<T>;\nexport function assertIsVariableSize<TFrom, TTo extends TFrom>(\n    codec: Codec<TFrom, TTo>,\n    message?: string,\n): asserts codec is VariableSizeCodec<TFrom, TTo>;\nexport function assertIsVariableSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n    message?: string,\n): asserts codec is { maxSize?: number };\nexport function assertIsVariableSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n    message?: string,\n): asserts codec is { maxSize?: number } {\n    if (!isVariableSize(codec)) {\n        // TODO: Coded error.\n        throw new Error(message ?? 'Expected a variable-size codec, got a fixed-size one.');\n    }\n}\n","/**\n * Asserts that a given string matches a given alphabet.\n */\nexport function assertValidBaseString(alphabet: string, testValue: string, givenValue = testValue) {\n    if (!testValue.match(new RegExp(`^[${alphabet}]*$`))) {\n        // TODO: Coded error.\n        throw new Error(`Expected a string of base ${alphabet.length}, got [${givenValue}].`);\n    }\n}\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\n\nimport { assertValidBaseString } from './assertions';\n\n/**\n * Encodes a string using a custom alphabet by dividing\n * by the base and handling leading zeroes.\n * @see {@link getBaseXCodec} for a more detailed description.\n */\nexport const getBaseXEncoder = (alphabet: string): VariableSizeEncoder<string> => {\n    return createEncoder({\n        getSizeFromValue: (value: string): number => {\n            const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet[0]);\n            if (tailChars === '') return value.length;\n\n            const base10Number = getBigIntFromBaseX(tailChars, alphabet);\n            return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);\n        },\n        write(value: string, bytes, offset) {\n            // Check if the value is valid.\n            assertValidBaseString(alphabet, value);\n            if (value === '') return offset;\n\n            // Handle leading zeroes.\n            const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet[0]);\n            if (tailChars === '') {\n                bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);\n                return offset + leadingZeroes.length;\n            }\n\n            // From baseX to base10.\n            let base10Number = getBigIntFromBaseX(tailChars, alphabet);\n\n            // From base10 to bytes.\n            const tailBytes: number[] = [];\n            while (base10Number > 0n) {\n                tailBytes.unshift(Number(base10Number % 256n));\n                base10Number /= 256n;\n            }\n\n            const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];\n            bytes.set(bytesToAdd, offset);\n            return offset + bytesToAdd.length;\n        },\n    });\n};\n\n/**\n * Decodes a string using a custom alphabet by dividing\n * by the base and handling leading zeroes.\n * @see {@link getBaseXCodec} for a more detailed description.\n */\nexport const getBaseXDecoder = (alphabet: string): VariableSizeDecoder<string> => {\n    return createDecoder({\n        read(rawBytes, offset): [string, number] {\n            const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n            if (bytes.length === 0) return ['', 0];\n\n            // Handle leading zeroes.\n            let trailIndex = bytes.findIndex(n => n !== 0);\n            trailIndex = trailIndex === -1 ? bytes.length : trailIndex;\n            const leadingZeroes = alphabet[0].repeat(trailIndex);\n            if (trailIndex === bytes.length) return [leadingZeroes, rawBytes.length];\n\n            // From bytes to base10.\n            const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);\n\n            // From base10 to baseX.\n            const tailChars = getBaseXFromBigInt(base10Number, alphabet);\n\n            return [leadingZeroes + tailChars, rawBytes.length];\n        },\n    });\n};\n\n/**\n * A string codec that requires a custom alphabet and uses\n * the length of that alphabet as the base. It then divides\n * the input by the base as many times as necessary to get\n * the output. It also supports leading zeroes by using the\n * first character of the alphabet as the zero character.\n *\n * This can be used to create codecs such as base10 or base58.\n */\nexport const getBaseXCodec = (alphabet: string): VariableSizeCodec<string> =>\n    combineCodec(getBaseXEncoder(alphabet), getBaseXDecoder(alphabet));\n\nfunction partitionLeadingZeroes(value: string, zeroCharacter: string): [string, string] {\n    const leadingZeroIndex = [...value].findIndex(c => c !== zeroCharacter);\n    return leadingZeroIndex === -1 ? [value, ''] : [value.slice(0, leadingZeroIndex), value.slice(leadingZeroIndex)];\n}\n\nfunction getBigIntFromBaseX(value: string, alphabet: string): bigint {\n    const base = BigInt(alphabet.length);\n    return [...value].reduce((sum, char) => sum * base + BigInt(alphabet.indexOf(char)), 0n);\n}\n\nfunction getBaseXFromBigInt(value: bigint, alphabet: string): string {\n    const base = BigInt(alphabet.length);\n    const tailChars = [];\n    while (value > 0n) {\n        tailChars.unshift(alphabet[Number(value % base)]);\n        value /= base;\n    }\n    return tailChars.join('');\n}\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\n\nimport { assertValidBaseString } from './assertions';\n\n/** Encodes strings in base16. */\nexport const getBase16Encoder = (): VariableSizeEncoder<string> =>\n    createEncoder({\n        getSizeFromValue: (value: string) => Math.ceil(value.length / 2),\n        write(value: string, bytes, offset) {\n            const lowercaseValue = value.toLowerCase();\n            assertValidBaseString('0123456789abcdef', lowercaseValue, value);\n            const matches = lowercaseValue.match(/.{1,2}/g);\n            const hexBytes = matches ? matches.map((byte: string) => parseInt(byte, 16)) : [];\n            bytes.set(hexBytes, offset);\n            return hexBytes.length + offset;\n        },\n    });\n\n/** Decodes strings in base16. */\nexport const getBase16Decoder = (): VariableSizeDecoder<string> =>\n    createDecoder({\n        read(bytes, offset) {\n            const value = bytes.slice(offset).reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');\n            return [value, bytes.length];\n        },\n    });\n\n/** Encodes and decodes strings in base16. */\nexport const getBase16Codec = (): VariableSizeCodec<string> => combineCodec(getBase16Encoder(), getBase16Decoder());\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\n\nimport { assertValidBaseString } from './assertions';\n\n/**\n * Encodes a string using a custom alphabet by reslicing the bits of the byte array.\n * @see {@link getBaseXResliceCodec} for a more detailed description.\n */\nexport const getBaseXResliceEncoder = (alphabet: string, bits: number): VariableSizeEncoder<string> =>\n    createEncoder({\n        getSizeFromValue: (value: string) => Math.floor((value.length * bits) / 8),\n        write(value: string, bytes, offset) {\n            assertValidBaseString(alphabet, value);\n            if (value === '') return offset;\n            const charIndices = [...value].map(c => alphabet.indexOf(c));\n            const reslicedBytes = reslice(charIndices, bits, 8, false);\n            bytes.set(reslicedBytes, offset);\n            return reslicedBytes.length + offset;\n        },\n    });\n\n/**\n * Decodes a string using a custom alphabet by reslicing the bits of the byte array.\n * @see {@link getBaseXResliceCodec} for a more detailed description.\n */\nexport const getBaseXResliceDecoder = (alphabet: string, bits: number): VariableSizeDecoder<string> =>\n    createDecoder({\n        read(rawBytes, offset = 0): [string, number] {\n            const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n            if (bytes.length === 0) return ['', rawBytes.length];\n            const charIndices = reslice([...bytes], 8, bits, true);\n            return [charIndices.map(i => alphabet[i]).join(''), rawBytes.length];\n        },\n    });\n\n/**\n * A string serializer that reslices bytes into custom chunks\n * of bits that are then mapped to a custom alphabet.\n *\n * This can be used to create serializers whose alphabet\n * is a power of 2 such as base16 or base64.\n */\nexport const getBaseXResliceCodec = (alphabet: string, bits: number): VariableSizeCodec<string> =>\n    combineCodec(getBaseXResliceEncoder(alphabet, bits), getBaseXResliceDecoder(alphabet, bits));\n\n/** Helper function to reslice the bits inside bytes. */\nfunction reslice(input: number[], inputBits: number, outputBits: number, useRemainder: boolean): number[] {\n    const output = [];\n    let accumulator = 0;\n    let bitsInAccumulator = 0;\n    const mask = (1 << outputBits) - 1;\n    for (const value of input) {\n        accumulator = (accumulator << inputBits) | value;\n        bitsInAccumulator += inputBits;\n        while (bitsInAccumulator >= outputBits) {\n            bitsInAccumulator -= outputBits;\n            output.push((accumulator >> bitsInAccumulator) & mask);\n        }\n    }\n    if (useRemainder && bitsInAccumulator > 0) {\n        output.push((accumulator << (outputBits - bitsInAccumulator)) & mask);\n    }\n    return output;\n}\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    mapDecoder,\n    mapEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\n\nimport { assertValidBaseString } from './assertions';\nimport { getBaseXResliceDecoder, getBaseXResliceEncoder } from './baseX-reslice';\n\nconst alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n/** Encodes strings in base64. */\nexport const getBase64Encoder = (): VariableSizeEncoder<string> => {\n    if (__BROWSER__) {\n        return createEncoder({\n            getSizeFromValue: (value: string) => {\n                try {\n                    return (atob as Window['atob'])(value).length;\n                } catch (e) {\n                    // TODO: Coded error.\n                    throw new Error(`Expected a string of base 64, got [${value}].`);\n                }\n            },\n            write(value: string, bytes, offset) {\n                try {\n                    const bytesToAdd = (atob as Window['atob'])(value)\n                        .split('')\n                        .map(c => c.charCodeAt(0));\n                    bytes.set(bytesToAdd, offset);\n                    return bytesToAdd.length + offset;\n                } catch (e) {\n                    // TODO: Coded error.\n                    throw new Error(`Expected a string of base 64, got [${value}].`);\n                }\n            },\n        });\n    }\n\n    if (__NODEJS__) {\n        return createEncoder({\n            getSizeFromValue: (value: string) => Buffer.from(value, 'base64').length,\n            write(value: string, bytes, offset) {\n                assertValidBaseString(alphabet, value.replace(/=/g, ''));\n                const buffer = Buffer.from(value, 'base64');\n                bytes.set(buffer, offset);\n                return buffer.length + offset;\n            },\n        });\n    }\n\n    return mapEncoder(getBaseXResliceEncoder(alphabet, 6), (value: string): string => value.replace(/=/g, ''));\n};\n\n/** Decodes strings in base64. */\nexport const getBase64Decoder = (): VariableSizeDecoder<string> => {\n    if (__BROWSER__) {\n        return createDecoder({\n            read(bytes, offset = 0) {\n                const slice = bytes.slice(offset);\n                const value = (btoa as Window['btoa'])(String.fromCharCode(...slice));\n                return [value, bytes.length];\n            },\n        });\n    }\n\n    if (__NODEJS__) {\n        return createDecoder({\n            read: (bytes, offset = 0) => [Buffer.from(bytes, offset).toString('base64'), bytes.length],\n        });\n    }\n\n    return mapDecoder(getBaseXResliceDecoder(alphabet, 6), (value: string): string =>\n        value.padEnd(Math.ceil(value.length / 4) * 4, '='),\n    );\n};\n\n/** Encodes and decodes strings in base64. */\nexport const getBase64Codec = (): VariableSizeCodec<string> => combineCodec(getBase64Encoder(), getBase64Decoder());\n","import type { Address } from '@solana/addresses';\nimport { getBase58Encoder, getBase64Encoder } from '@solana/codecs-strings';\nimport type {\n    AccountInfoBase,\n    AccountInfoWithBase58Bytes,\n    AccountInfoWithBase58EncodedData,\n    AccountInfoWithBase64EncodedData,\n} from '@solana/rpc-core/dist/types/rpc-methods/common';\n\nimport type { Account, BaseAccount, EncodedAccount } from './account';\nimport { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\ntype Base64EncodedRpcAccount = AccountInfoBase & AccountInfoWithBase64EncodedData;\n\n/** Parse an account object received from a base64-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase64Encoder().encode(rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype Base58EncodedRpcAccount = AccountInfoBase & (AccountInfoWithBase58Bytes | AccountInfoWithBase58EncodedData);\n\n/** Parse an account object received from a base58-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase58Encoder().encode(typeof rpcAccount.data === 'string' ? rpcAccount.data : rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype JsonParsedRpcAccount = AccountInfoBase & { readonly data: JsonParsedData<unknown> };\ntype JsonParsedData<TData> = { readonly parsed: { readonly info: TData } };\n\n/** Parse an account object received from a json-parsed RPC call into an Account or MaybeAccount type. */\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount,\n): Account<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): MaybeAccount<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = rpcAccount.data.parsed.info as TData;\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\nfunction parseBaseAccount(rpcAccount: AccountInfoBase): BaseAccount {\n    return Object.freeze({\n        executable: rpcAccount.executable,\n        lamports: rpcAccount.lamports,\n        programAddress: rpcAccount.owner,\n    });\n}\n","import type { Address } from '@solana/addresses';\nimport type { Slot } from '@solana/rpc-core/dist/types/rpc-methods/common';\nimport type { GetAccountInfoApi } from '@solana/rpc-core/dist/types/rpc-methods/getAccountInfo';\nimport type { GetMultipleAccountsApi } from '@solana/rpc-core/dist/types/rpc-methods/getMultipleAccounts';\nimport type { Rpc } from '@solana/rpc-transport/dist/types/json-rpc-types';\nimport type { Commitment } from '@solana/rpc-types';\n\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\nimport { parseBase64RpcAccount, parseJsonRpcAccount } from './parse-account';\n\n/** Optional configuration for fetching a singular account. */\nexport type FetchAccountConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch a base64-encoded account that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccount<TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc.getAccountInfo(address, { ...rpcConfig, encoding: 'base64' }).send({ abortSignal });\n    return parseBase64RpcAccount(address, response.value);\n}\n\n/** Fetch a json-parsed account that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccount<TData extends object, TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeAccount<TData, TAddress> | MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const { value: account } = await rpc\n        .getAccountInfo(address, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return !!account && typeof account === 'object' && 'parsed' in account.data\n        ? parseJsonRpcAccount<TData, TAddress>(address, account as Parameters<typeof parseJsonRpcAccount>[1])\n        : parseBase64RpcAccount<TAddress>(address, account as Parameters<typeof parseBase64RpcAccount>[1]);\n}\n\n/** Optional configuration for fetching multiple accounts. */\nexport type FetchAccountsConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch multiple base64-encoded accounts that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccounts<\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'base64' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => parseBase64RpcAccount(addresses[index], account)) as {\n        [P in keyof TAddresses]: MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n\n/** Fetch multiple json-parsed accounts that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccounts<\n    TData extends object[],\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => {\n        return !!account && typeof account === 'object' && 'parsed' in account.data\n            ? parseJsonRpcAccount(addresses[index], account as Parameters<typeof parseJsonRpcAccount>[1])\n            : parseBase64RpcAccount(addresses[index], account as Parameters<typeof parseBase64RpcAccount>[1]);\n    }) as {\n        [P in keyof TData]:\n            | MaybeAccount<TData[P], TAddresses[P & keyof TAddresses]>\n            | MaybeEncodedAccount<TAddresses[P & keyof TAddresses]>;\n    } & {\n        [P in keyof TAddresses]:\n            | MaybeAccount<TData[P & keyof TData], TAddresses[P]>\n            | MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n","import { Address } from '@solana/addresses';\n\nimport { Account } from './account';\n\n/** Defines a Solana account that may or may not exist after having tried to fetch it. */\nexport type MaybeAccount<TData extends object | Uint8Array, TAddress extends string = string> =\n    | ({ readonly exists: true } & Account<TData, TAddress>)\n    | { readonly exists: false; readonly address: Address<TAddress> };\n\n/** Defines a Solana account with encoded data that may or may not exist after having tried to fetch it. */\nexport type MaybeEncodedAccount<TAddress extends string = string> = MaybeAccount<Uint8Array, TAddress>;\n\n/** Asserts that an account that may or may not exists, actually exists. */\nexport function assertAccountExists<TData extends object | Uint8Array, TAddress extends string = string>(\n    account: MaybeAccount<TData, TAddress>\n): asserts account is Account<TData, TAddress> & { exists: true } {\n    if (!account.exists) {\n        // TODO: Coded error.\n        throw new Error(`Expected account [${account.address}] to exist.`);\n    }\n}\n"]}

package/dist/index.native.js

@@ -0,0 +1,78 @@
+import { getBase64Encoder, getBase58Encoder } from '@solana/codecs-strings';
+
+// src/account.ts
+var BASE_ACCOUNT_SIZE = 128;
+
+// src/decode-account.ts
+function decodeAccount(encodedAccount, decoder) {
+  try {
+    if ("exists" in encodedAccount && !encodedAccount.exists) {
+      return encodedAccount;
+    }
+    return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
+  } catch (error) {
+    const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);
+    newError.cause = error;
+    throw newError;
+  }
+}
+function parseBase64RpcAccount(address, rpcAccount) {
+  if (!rpcAccount)
+    return Object.freeze({ address, exists: false });
+  const data = getBase64Encoder().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;
+  return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
+}
+function parseBaseAccount(rpcAccount) {
+  return Object.freeze({
+    executable: rpcAccount.executable,
+    lamports: rpcAccount.lamports,
+    programAddress: rpcAccount.owner
+  });
+}
+
+// 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);
+  });
+}
+
+// src/maybe-account.ts
+function assertAccountExists(account) {
+  if (!account.exists) {
+    throw new Error(`Expected account [${account.address}] to exist.`);
+  }
+}
+
+export { BASE_ACCOUNT_SIZE, assertAccountExists, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.native.js.map

package/dist/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/account.ts","../src/decode-account.ts","../src/parse-account.ts","../src/fetch-account.ts","../src/maybe-account.ts"],"names":[],"mappings":";AAIO,IAAM,oBAAoB;;;ACU1B,SAAS,cACZ,gBACA,SACwD;AACxD,MAAI;AACA,QAAI,YAAY,kBAAkB,CAAC,eAAe,QAAQ;AACtD,aAAO;AAAA,IACX;AACA,WAAO,OAAO,OAAO,EAAE,GAAG,gBAAgB,MAAM,QAAQ,OAAO,eAAe,IAAI,EAAE,CAAC;AAAA,EACzF,SAAS,OAAO;AAEZ,UAAM,WAAW,IAAI,MAAM,6BAA6B,eAAe,OAAO,IAAI;AAClF,aAAS,QAAQ;AACjB,UAAM;AAAA,EACV;AACJ;;;AC5BA,SAAS,kBAAkB,wBAAwB;AAsB5C,SAAS,sBACZ,SACA,YACwD;AACxD,MAAI,CAAC;AAAY,WAAO,OAAO,OAAO,EAAE,SAAS,QAAQ,MAAM,CAAC;AAChE,QAAM,OAAO,iBAAiB,EAAE,OAAO,WAAW,KAAK,CAAC,CAAC;AACzD,SAAO,OAAO,OAAO,EAAE,GAAG,iBAAiB,UAAU,GAAG,SAAS,MAAM,QAAQ,KAAK,CAAC;AACzF;AAaO,SAAS,sBACZ,SACA,YACwD;AACxD,MAAI,CAAC;AAAY,WAAO,OAAO,OAAO,EAAE,SAAS,QAAQ,MAAM,CAAC;AAChE,QAAM,OAAO,iBAAiB,EAAE,OAAO,OAAO,WAAW,SAAS,WAAW,WAAW,OAAO,WAAW,KAAK,CAAC,CAAC;AACjH,SAAO,OAAO,OAAO,EAAE,GAAG,iBAAiB,UAAU,GAAG,SAAS,MAAM,QAAQ,KAAK,CAAC;AACzF;AAcO,SAAS,oBACZ,SACA,YACwD;AACxD,MAAI,CAAC;AAAY,WAAO,OAAO,OAAO,EAAE,SAAS,QAAQ,MAAM,CAAC;AAChE,QAAM,OAAO,WAAW,KAAK,OAAO;AACpC,SAAO,OAAO,OAAO,EAAE,GAAG,iBAAiB,UAAU,GAAG,SAAS,MAAM,QAAQ,KAAK,CAAC;AACzF;AAEA,SAAS,iBAAiB,YAA0C;AAChE,SAAO,OAAO,OAAO;AAAA,IACjB,YAAY,WAAW;AAAA,IACvB,UAAU,WAAW;AAAA,IACrB,gBAAgB,WAAW;AAAA,EAC/B,CAAC;AACL;;;AC7DA,eAAsB,oBAClB,KACA,SACA,SAA6B,CAAC,GACQ;AACtC,QAAM,EAAE,aAAa,GAAG,UAAU,IAAI;AACtC,QAAM,WAAW,MAAM,IAAI,eAAe,SAAS,EAAE,GAAG,WAAW,UAAU,SAAS,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC;AAC7G,SAAO,sBAAsB,SAAS,SAAS,KAAK;AACxD;AAGA,eAAsB,uBAClB,KACA,SACA,SAA6B,CAAC,GACwC;AACtE,QAAM,EAAE,aAAa,GAAG,UAAU,IAAI;AACtC,QAAM,EAAE,OAAO,QAAQ,IAAI,MAAM,IAC5B,eAAe,SAAS,EAAE,GAAG,WAAW,UAAU,aAAa,CAAC,EAChE,KAAK,EAAE,YAAY,CAAC;AACzB,SAAO,CAAC,CAAC,WAAW,OAAO,YAAY,YAAY,YAAY,QAAQ,OACjE,oBAAqC,SAAS,OAAoD,IAClG,sBAAgC,SAAS,OAAsD;AACzG;AAUA,eAAsB,qBAKpB,KAAkC,WAA8B,SAA8B,CAAC,GAAG;AAChG,QAAM,EAAE,aAAa,GAAG,UAAU,IAAI;AACtC,QAAM,WAAW,MAAM,IAClB,oBAAoB,WAAW,EAAE,GAAG,WAAW,UAAU,SAAS,CAAC,EACnE,KAAK,EAAE,YAAY,CAAC;AACzB,SAAO,SAAS,MAAM,IAAI,CAAC,SAAS,UAAU,sBAAsB,UAAU,KAAK,GAAG,OAAO,CAAC;AAGlG;AAGA,eAAsB,wBAMpB,KAAkC,WAA8B,SAA8B,CAAC,GAAG;AAChG,QAAM,EAAE,aAAa,GAAG,UAAU,IAAI;AACtC,QAAM,WAAW,MAAM,IAClB,oBAAoB,WAAW,EAAE,GAAG,WAAW,UAAU,aAAa,CAAC,EACvE,KAAK,EAAE,YAAY,CAAC;AACzB,SAAO,SAAS,MAAM,IAAI,CAAC,SAAS,UAAU;AAC1C,WAAO,CAAC,CAAC,WAAW,OAAO,YAAY,YAAY,YAAY,QAAQ,OACjE,oBAAoB,UAAU,KAAK,GAAG,OAAoD,IAC1F,sBAAsB,UAAU,KAAK,GAAG,OAAsD;AAAA,EACxG,CAAC;AASL;;;AC9EO,SAAS,oBACZ,SAC8D;AAC9D,MAAI,CAAC,QAAQ,QAAQ;AAEjB,UAAM,IAAI,MAAM,qBAAqB,QAAQ,OAAO,aAAa;AAAA,EACrE;AACJ","sourcesContent":["import type { Address } from '@solana/addresses';\nimport type { LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';\n\n/** The amount of bytes required to store the base account information without its data. */\nexport const BASE_ACCOUNT_SIZE = 128;\n\n/** Describe the generic account details applicable to every account. */\nexport type BaseAccount = {\n    readonly programAddress: Address;\n    readonly executable: boolean;\n    readonly lamports: LamportsUnsafeBeyond2Pow53Minus1;\n};\n\n/** Defines a Solana account with its generic details and parsed or encoded data. */\nexport type Account<TData extends object | Uint8Array, TAddress extends string = string> = BaseAccount & {\n    readonly address: Address<TAddress>;\n    readonly data: TData;\n};\n\n/** Defines a Solana account with its generic details and encoded data. */\nexport type EncodedAccount<TAddress extends string = string> = Account<Uint8Array, TAddress>;\n","import type { Decoder } from '@solana/codecs-core';\n\nimport type { Account, EncodedAccount } from './account';\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\n/** Decodes the data of a given account using the provided decoder. */\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): MaybeAccount<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    try {\n        if ('exists' in encodedAccount && !encodedAccount.exists) {\n            return encodedAccount;\n        }\n        return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });\n    } catch (error) {\n        // TODO: Coded error.\n        const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);\n        newError.cause = error;\n        throw newError;\n    }\n}\n","import type { Address } from '@solana/addresses';\nimport { getBase58Encoder, getBase64Encoder } from '@solana/codecs-strings';\nimport type {\n    AccountInfoBase,\n    AccountInfoWithBase58Bytes,\n    AccountInfoWithBase58EncodedData,\n    AccountInfoWithBase64EncodedData,\n} from '@solana/rpc-core/dist/types/rpc-methods/common';\n\nimport type { Account, BaseAccount, EncodedAccount } from './account';\nimport { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\ntype Base64EncodedRpcAccount = AccountInfoBase & AccountInfoWithBase64EncodedData;\n\n/** Parse an account object received from a base64-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase64Encoder().encode(rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype Base58EncodedRpcAccount = AccountInfoBase & (AccountInfoWithBase58Bytes | AccountInfoWithBase58EncodedData);\n\n/** Parse an account object received from a base58-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase58Encoder().encode(typeof rpcAccount.data === 'string' ? rpcAccount.data : rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype JsonParsedRpcAccount = AccountInfoBase & { readonly data: JsonParsedData<unknown> };\ntype JsonParsedData<TData> = { readonly parsed: { readonly info: TData } };\n\n/** Parse an account object received from a json-parsed RPC call into an Account or MaybeAccount type. */\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount,\n): Account<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): MaybeAccount<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = rpcAccount.data.parsed.info as TData;\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\nfunction parseBaseAccount(rpcAccount: AccountInfoBase): BaseAccount {\n    return Object.freeze({\n        executable: rpcAccount.executable,\n        lamports: rpcAccount.lamports,\n        programAddress: rpcAccount.owner,\n    });\n}\n","import type { Address } from '@solana/addresses';\nimport type { Slot } from '@solana/rpc-core/dist/types/rpc-methods/common';\nimport type { GetAccountInfoApi } from '@solana/rpc-core/dist/types/rpc-methods/getAccountInfo';\nimport type { GetMultipleAccountsApi } from '@solana/rpc-core/dist/types/rpc-methods/getMultipleAccounts';\nimport type { Rpc } from '@solana/rpc-transport/dist/types/json-rpc-types';\nimport type { Commitment } from '@solana/rpc-types';\n\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\nimport { parseBase64RpcAccount, parseJsonRpcAccount } from './parse-account';\n\n/** Optional configuration for fetching a singular account. */\nexport type FetchAccountConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch a base64-encoded account that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccount<TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc.getAccountInfo(address, { ...rpcConfig, encoding: 'base64' }).send({ abortSignal });\n    return parseBase64RpcAccount(address, response.value);\n}\n\n/** Fetch a json-parsed account that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccount<TData extends object, TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeAccount<TData, TAddress> | MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const { value: account } = await rpc\n        .getAccountInfo(address, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return !!account && typeof account === 'object' && 'parsed' in account.data\n        ? parseJsonRpcAccount<TData, TAddress>(address, account as Parameters<typeof parseJsonRpcAccount>[1])\n        : parseBase64RpcAccount<TAddress>(address, account as Parameters<typeof parseBase64RpcAccount>[1]);\n}\n\n/** Optional configuration for fetching multiple accounts. */\nexport type FetchAccountsConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch multiple base64-encoded accounts that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccounts<\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'base64' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => parseBase64RpcAccount(addresses[index], account)) as {\n        [P in keyof TAddresses]: MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n\n/** Fetch multiple json-parsed accounts that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccounts<\n    TData extends object[],\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => {\n        return !!account && typeof account === 'object' && 'parsed' in account.data\n            ? parseJsonRpcAccount(addresses[index], account as Parameters<typeof parseJsonRpcAccount>[1])\n            : parseBase64RpcAccount(addresses[index], account as Parameters<typeof parseBase64RpcAccount>[1]);\n    }) as {\n        [P in keyof TData]:\n            | MaybeAccount<TData[P], TAddresses[P & keyof TAddresses]>\n            | MaybeEncodedAccount<TAddresses[P & keyof TAddresses]>;\n    } & {\n        [P in keyof TAddresses]:\n            | MaybeAccount<TData[P & keyof TData], TAddresses[P]>\n            | MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n","import { Address } from '@solana/addresses';\n\nimport { Account } from './account';\n\n/** Defines a Solana account that may or may not exist after having tried to fetch it. */\nexport type MaybeAccount<TData extends object | Uint8Array, TAddress extends string = string> =\n    | ({ readonly exists: true } & Account<TData, TAddress>)\n    | { readonly exists: false; readonly address: Address<TAddress> };\n\n/** Defines a Solana account with encoded data that may or may not exist after having tried to fetch it. */\nexport type MaybeEncodedAccount<TAddress extends string = string> = MaybeAccount<Uint8Array, TAddress>;\n\n/** Asserts that an account that may or may not exists, actually exists. */\nexport function assertAccountExists<TData extends object | Uint8Array, TAddress extends string = string>(\n    account: MaybeAccount<TData, TAddress>\n): asserts account is Account<TData, TAddress> & { exists: true } {\n    if (!account.exists) {\n        // TODO: Coded error.\n        throw new Error(`Expected account [${account.address}] to exist.`);\n    }\n}\n"]}

package/dist/index.node.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+var codecsStrings = require('@solana/codecs-strings');
+
+// src/account.ts
+var BASE_ACCOUNT_SIZE = 128;
+
+// src/decode-account.ts
+function decodeAccount(encodedAccount, decoder) {
+  try {
+    if ("exists" in encodedAccount && !encodedAccount.exists) {
+      return encodedAccount;
+    }
+    return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
+  } catch (error) {
+    const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);
+    newError.cause = error;
+    throw newError;
+  }
+}
+function parseBase64RpcAccount(address, rpcAccount) {
+  if (!rpcAccount)
+    return Object.freeze({ address, exists: false });
+  const data = codecsStrings.getBase64Encoder().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 = codecsStrings.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;
+  return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
+}
+function parseBaseAccount(rpcAccount) {
+  return Object.freeze({
+    executable: rpcAccount.executable,
+    lamports: rpcAccount.lamports,
+    programAddress: rpcAccount.owner
+  });
+}
+
+// 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);
+  });
+}
+
+// src/maybe-account.ts
+function assertAccountExists(account) {
+  if (!account.exists) {
+    throw new Error(`Expected account [${account.address}] to exist.`);
+  }
+}
+
+exports.BASE_ACCOUNT_SIZE = BASE_ACCOUNT_SIZE;
+exports.assertAccountExists = assertAccountExists;
+exports.decodeAccount = decodeAccount;
+exports.fetchEncodedAccount = fetchEncodedAccount;
+exports.fetchEncodedAccounts = fetchEncodedAccounts;
+exports.fetchJsonParsedAccount = fetchJsonParsedAccount;
+exports.fetchJsonParsedAccounts = fetchJsonParsedAccounts;
+exports.parseBase58RpcAccount = parseBase58RpcAccount;
+exports.parseBase64RpcAccount = parseBase64RpcAccount;
+exports.parseJsonRpcAccount = parseJsonRpcAccount;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.node.cjs.map

package/dist/index.node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/account.ts","../src/decode-account.ts","../src/parse-account.ts","../src/fetch-account.ts","../src/maybe-account.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Address } from '@solana/addresses';\nimport type { LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';\n\n/** The amount of bytes required to store the base account information without its data. */\nexport const BASE_ACCOUNT_SIZE = 128;\n\n/** Describe the generic account details applicable to every account. */\nexport type BaseAccount = {\n    readonly programAddress: Address;\n    readonly executable: boolean;\n    readonly lamports: LamportsUnsafeBeyond2Pow53Minus1;\n};\n\n/** Defines a Solana account with its generic details and parsed or encoded data. */\nexport type Account<TData extends object | Uint8Array, TAddress extends string = string> = BaseAccount & {\n    readonly address: Address<TAddress>;\n    readonly data: TData;\n};\n\n/** Defines a Solana account with its generic details and encoded data. */\nexport type EncodedAccount<TAddress extends string = string> = Account<Uint8Array, TAddress>;\n","import type { Decoder } from '@solana/codecs-core';\n\nimport type { Account, EncodedAccount } from './account';\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\n/** Decodes the data of a given account using the provided decoder. */\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): MaybeAccount<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    try {\n        if ('exists' in encodedAccount && !encodedAccount.exists) {\n            return encodedAccount;\n        }\n        return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });\n    } catch (error) {\n        // TODO: Coded error.\n        const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);\n        newError.cause = error;\n        throw newError;\n    }\n}\n","import type { Address } from '@solana/addresses';\nimport { getBase58Encoder, getBase64Encoder } from '@solana/codecs-strings';\nimport type {\n    AccountInfoBase,\n    AccountInfoWithBase58Bytes,\n    AccountInfoWithBase58EncodedData,\n    AccountInfoWithBase64EncodedData,\n} from '@solana/rpc-core/dist/types/rpc-methods/common';\n\nimport type { Account, BaseAccount, EncodedAccount } from './account';\nimport { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\ntype Base64EncodedRpcAccount = AccountInfoBase & AccountInfoWithBase64EncodedData;\n\n/** Parse an account object received from a base64-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase64Encoder().encode(rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype Base58EncodedRpcAccount = AccountInfoBase & (AccountInfoWithBase58Bytes | AccountInfoWithBase58EncodedData);\n\n/** Parse an account object received from a base58-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase58Encoder().encode(typeof rpcAccount.data === 'string' ? rpcAccount.data : rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype JsonParsedRpcAccount = AccountInfoBase & { readonly data: JsonParsedData<unknown> };\ntype JsonParsedData<TData> = { readonly parsed: { readonly info: TData } };\n\n/** Parse an account object received from a json-parsed RPC call into an Account or MaybeAccount type. */\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount,\n): Account<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): MaybeAccount<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = rpcAccount.data.parsed.info as TData;\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\nfunction parseBaseAccount(rpcAccount: AccountInfoBase): BaseAccount {\n    return Object.freeze({\n        executable: rpcAccount.executable,\n        lamports: rpcAccount.lamports,\n        programAddress: rpcAccount.owner,\n    });\n}\n","import type { Address } from '@solana/addresses';\nimport type { Slot } from '@solana/rpc-core/dist/types/rpc-methods/common';\nimport type { GetAccountInfoApi } from '@solana/rpc-core/dist/types/rpc-methods/getAccountInfo';\nimport type { GetMultipleAccountsApi } from '@solana/rpc-core/dist/types/rpc-methods/getMultipleAccounts';\nimport type { Rpc } from '@solana/rpc-transport/dist/types/json-rpc-types';\nimport type { Commitment } from '@solana/rpc-types';\n\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\nimport { parseBase64RpcAccount, parseJsonRpcAccount } from './parse-account';\n\n/** Optional configuration for fetching a singular account. */\nexport type FetchAccountConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch a base64-encoded account that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccount<TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc.getAccountInfo(address, { ...rpcConfig, encoding: 'base64' }).send({ abortSignal });\n    return parseBase64RpcAccount(address, response.value);\n}\n\n/** Fetch a json-parsed account that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccount<TData extends object, TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeAccount<TData, TAddress> | MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const { value: account } = await rpc\n        .getAccountInfo(address, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return !!account && typeof account === 'object' && 'parsed' in account.data\n        ? parseJsonRpcAccount<TData, TAddress>(address, account as Parameters<typeof parseJsonRpcAccount>[1])\n        : parseBase64RpcAccount<TAddress>(address, account as Parameters<typeof parseBase64RpcAccount>[1]);\n}\n\n/** Optional configuration for fetching multiple accounts. */\nexport type FetchAccountsConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch multiple base64-encoded accounts that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccounts<\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'base64' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => parseBase64RpcAccount(addresses[index], account)) as {\n        [P in keyof TAddresses]: MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n\n/** Fetch multiple json-parsed accounts that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccounts<\n    TData extends object[],\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => {\n        return !!account && typeof account === 'object' && 'parsed' in account.data\n            ? parseJsonRpcAccount(addresses[index], account as Parameters<typeof parseJsonRpcAccount>[1])\n            : parseBase64RpcAccount(addresses[index], account as Parameters<typeof parseBase64RpcAccount>[1]);\n    }) as {\n        [P in keyof TData]:\n            | MaybeAccount<TData[P], TAddresses[P & keyof TAddresses]>\n            | MaybeEncodedAccount<TAddresses[P & keyof TAddresses]>;\n    } & {\n        [P in keyof TAddresses]:\n            | MaybeAccount<TData[P & keyof TData], TAddresses[P]>\n            | MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n","import { Address } from '@solana/addresses';\n\nimport { Account } from './account';\n\n/** Defines a Solana account that may or may not exist after having tried to fetch it. */\nexport type MaybeAccount<TData extends object | Uint8Array, TAddress extends string = string> =\n    | ({ readonly exists: true } & Account<TData, TAddress>)\n    | { readonly exists: false; readonly address: Address<TAddress> };\n\n/** Defines a Solana account with encoded data that may or may not exist after having tried to fetch it. */\nexport type MaybeEncodedAccount<TAddress extends string = string> = MaybeAccount<Uint8Array, TAddress>;\n\n/** Asserts that an account that may or may not exists, actually exists. */\nexport function assertAccountExists<TData extends object | Uint8Array, TAddress extends string = string>(\n    account: MaybeAccount<TData, TAddress>\n): asserts account is Account<TData, TAddress> & { exists: true } {\n    if (!account.exists) {\n        // TODO: Coded error.\n        throw new Error(`Expected account [${account.address}] to exist.`);\n    }\n}\n"]}

package/dist/index.node.js

@@ -0,0 +1,78 @@
+import { getBase64Encoder, getBase58Encoder } from '@solana/codecs-strings';
+
+// src/account.ts
+var BASE_ACCOUNT_SIZE = 128;
+
+// src/decode-account.ts
+function decodeAccount(encodedAccount, decoder) {
+  try {
+    if ("exists" in encodedAccount && !encodedAccount.exists) {
+      return encodedAccount;
+    }
+    return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });
+  } catch (error) {
+    const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);
+    newError.cause = error;
+    throw newError;
+  }
+}
+function parseBase64RpcAccount(address, rpcAccount) {
+  if (!rpcAccount)
+    return Object.freeze({ address, exists: false });
+  const data = getBase64Encoder().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;
+  return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });
+}
+function parseBaseAccount(rpcAccount) {
+  return Object.freeze({
+    executable: rpcAccount.executable,
+    lamports: rpcAccount.lamports,
+    programAddress: rpcAccount.owner
+  });
+}
+
+// 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);
+  });
+}
+
+// src/maybe-account.ts
+function assertAccountExists(account) {
+  if (!account.exists) {
+    throw new Error(`Expected account [${account.address}] to exist.`);
+  }
+}
+
+export { BASE_ACCOUNT_SIZE, assertAccountExists, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.node.js.map

package/dist/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/account.ts","../src/decode-account.ts","../src/parse-account.ts","../src/fetch-account.ts","../src/maybe-account.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Address } from '@solana/addresses';\nimport type { LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';\n\n/** The amount of bytes required to store the base account information without its data. */\nexport const BASE_ACCOUNT_SIZE = 128;\n\n/** Describe the generic account details applicable to every account. */\nexport type BaseAccount = {\n    readonly programAddress: Address;\n    readonly executable: boolean;\n    readonly lamports: LamportsUnsafeBeyond2Pow53Minus1;\n};\n\n/** Defines a Solana account with its generic details and parsed or encoded data. */\nexport type Account<TData extends object | Uint8Array, TAddress extends string = string> = BaseAccount & {\n    readonly address: Address<TAddress>;\n    readonly data: TData;\n};\n\n/** Defines a Solana account with its generic details and encoded data. */\nexport type EncodedAccount<TAddress extends string = string> = Account<Uint8Array, TAddress>;\n","import type { Decoder } from '@solana/codecs-core';\n\nimport type { Account, EncodedAccount } from './account';\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\n/** Decodes the data of a given account using the provided decoder. */\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): MaybeAccount<TData, TAddress>;\nexport function decodeAccount<TData extends object, TAddress extends string = string>(\n    encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,\n    decoder: Decoder<TData>\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    try {\n        if ('exists' in encodedAccount && !encodedAccount.exists) {\n            return encodedAccount;\n        }\n        return Object.freeze({ ...encodedAccount, data: decoder.decode(encodedAccount.data) });\n    } catch (error) {\n        // TODO: Coded error.\n        const newError = new Error(`Failed to decode account [${encodedAccount.address}].`);\n        newError.cause = error;\n        throw newError;\n    }\n}\n","import type { Address } from '@solana/addresses';\nimport { getBase58Encoder, getBase64Encoder } from '@solana/codecs-strings';\nimport type {\n    AccountInfoBase,\n    AccountInfoWithBase58Bytes,\n    AccountInfoWithBase58EncodedData,\n    AccountInfoWithBase64EncodedData,\n} from '@solana/rpc-core/dist/types/rpc-methods/common';\n\nimport type { Account, BaseAccount, EncodedAccount } from './account';\nimport { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\n\ntype Base64EncodedRpcAccount = AccountInfoBase & AccountInfoWithBase64EncodedData;\n\n/** Parse an account object received from a base64-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase64RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base64EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase64Encoder().encode(rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype Base58EncodedRpcAccount = AccountInfoBase & (AccountInfoWithBase58Bytes | AccountInfoWithBase58EncodedData);\n\n/** Parse an account object received from a base58-encoded RPC call into an EncodedAccount or MaybeEncodedAccount type. */\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount,\n): EncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): MaybeEncodedAccount<TAddress>;\nexport function parseBase58RpcAccount<TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: Base58EncodedRpcAccount | null,\n): EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = getBase58Encoder().encode(typeof rpcAccount.data === 'string' ? rpcAccount.data : rpcAccount.data[0]);\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\ntype JsonParsedRpcAccount = AccountInfoBase & { readonly data: JsonParsedData<unknown> };\ntype JsonParsedData<TData> = { readonly parsed: { readonly info: TData } };\n\n/** Parse an account object received from a json-parsed RPC call into an Account or MaybeAccount type. */\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount,\n): Account<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): MaybeAccount<TData, TAddress>;\nexport function parseJsonRpcAccount<TData extends object, TAddress extends string = string>(\n    address: Address<TAddress>,\n    rpcAccount: JsonParsedRpcAccount | null,\n): Account<TData, TAddress> | MaybeAccount<TData, TAddress> {\n    if (!rpcAccount) return Object.freeze({ address, exists: false });\n    const data = rpcAccount.data.parsed.info as TData;\n    return Object.freeze({ ...parseBaseAccount(rpcAccount), address, data, exists: true });\n}\n\nfunction parseBaseAccount(rpcAccount: AccountInfoBase): BaseAccount {\n    return Object.freeze({\n        executable: rpcAccount.executable,\n        lamports: rpcAccount.lamports,\n        programAddress: rpcAccount.owner,\n    });\n}\n","import type { Address } from '@solana/addresses';\nimport type { Slot } from '@solana/rpc-core/dist/types/rpc-methods/common';\nimport type { GetAccountInfoApi } from '@solana/rpc-core/dist/types/rpc-methods/getAccountInfo';\nimport type { GetMultipleAccountsApi } from '@solana/rpc-core/dist/types/rpc-methods/getMultipleAccounts';\nimport type { Rpc } from '@solana/rpc-transport/dist/types/json-rpc-types';\nimport type { Commitment } from '@solana/rpc-types';\n\nimport type { MaybeAccount, MaybeEncodedAccount } from './maybe-account';\nimport { parseBase64RpcAccount, parseJsonRpcAccount } from './parse-account';\n\n/** Optional configuration for fetching a singular account. */\nexport type FetchAccountConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch a base64-encoded account that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccount<TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc.getAccountInfo(address, { ...rpcConfig, encoding: 'base64' }).send({ abortSignal });\n    return parseBase64RpcAccount(address, response.value);\n}\n\n/** Fetch a json-parsed account that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccount<TData extends object, TAddress extends string = string>(\n    rpc: Rpc<GetAccountInfoApi>,\n    address: Address<TAddress>,\n    config: FetchAccountConfig = {},\n): Promise<MaybeAccount<TData, TAddress> | MaybeEncodedAccount<TAddress>> {\n    const { abortSignal, ...rpcConfig } = config;\n    const { value: account } = await rpc\n        .getAccountInfo(address, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return !!account && typeof account === 'object' && 'parsed' in account.data\n        ? parseJsonRpcAccount<TData, TAddress>(address, account as Parameters<typeof parseJsonRpcAccount>[1])\n        : parseBase64RpcAccount<TAddress>(address, account as Parameters<typeof parseBase64RpcAccount>[1]);\n}\n\n/** Optional configuration for fetching multiple accounts. */\nexport type FetchAccountsConfig = {\n    commitment?: Commitment;\n    minContextSlot?: Slot;\n    abortSignal?: AbortSignal;\n};\n\n/** Fetch multiple base64-encoded accounts that may or may not exist using an RPC client. */\nexport async function fetchEncodedAccounts<\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'base64' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => parseBase64RpcAccount(addresses[index], account)) as {\n        [P in keyof TAddresses]: MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n\n/** Fetch multiple json-parsed accounts that may or may not exist using an RPC client. */\nexport async function fetchJsonParsedAccounts<\n    TData extends object[],\n    TAddresses extends string[] = string[],\n    TWrappedAddresses extends { [P in keyof TAddresses]: Address<TAddresses[P]> } = {\n        [P in keyof TAddresses]: Address<TAddresses[P]>;\n    },\n>(rpc: Rpc<GetMultipleAccountsApi>, addresses: TWrappedAddresses, config: FetchAccountsConfig = {}) {\n    const { abortSignal, ...rpcConfig } = config;\n    const response = await rpc\n        .getMultipleAccounts(addresses, { ...rpcConfig, encoding: 'jsonParsed' })\n        .send({ abortSignal });\n    return response.value.map((account, index) => {\n        return !!account && typeof account === 'object' && 'parsed' in account.data\n            ? parseJsonRpcAccount(addresses[index], account as Parameters<typeof parseJsonRpcAccount>[1])\n            : parseBase64RpcAccount(addresses[index], account as Parameters<typeof parseBase64RpcAccount>[1]);\n    }) as {\n        [P in keyof TData]:\n            | MaybeAccount<TData[P], TAddresses[P & keyof TAddresses]>\n            | MaybeEncodedAccount<TAddresses[P & keyof TAddresses]>;\n    } & {\n        [P in keyof TAddresses]:\n            | MaybeAccount<TData[P & keyof TData], TAddresses[P]>\n            | MaybeEncodedAccount<TAddresses[P]>;\n    };\n}\n","import { Address } from '@solana/addresses';\n\nimport { Account } from './account';\n\n/** Defines a Solana account that may or may not exist after having tried to fetch it. */\nexport type MaybeAccount<TData extends object | Uint8Array, TAddress extends string = string> =\n    | ({ readonly exists: true } & Account<TData, TAddress>)\n    | { readonly exists: false; readonly address: Address<TAddress> };\n\n/** Defines a Solana account with encoded data that may or may not exist after having tried to fetch it. */\nexport type MaybeEncodedAccount<TAddress extends string = string> = MaybeAccount<Uint8Array, TAddress>;\n\n/** Asserts that an account that may or may not exists, actually exists. */\nexport function assertAccountExists<TData extends object | Uint8Array, TAddress extends string = string>(\n    account: MaybeAccount<TData, TAddress>\n): asserts account is Account<TData, TAddress> & { exists: true } {\n    if (!account.exists) {\n        // TODO: Coded error.\n        throw new Error(`Expected account [${account.address}] to exist.`);\n    }\n}\n"]}