@debridge-finance/solana-utils 5.3.2 → 5.4.0

package/dist/browser/index.js

@@ -10124,6 +10124,7 @@ function parseSplAccount(dataOrInfo) {
         return null;
     }
     const data = "executable" in dataOrInfo ? dataOrInfo.data : dataOrInfo;
+    data.subarray(0, 165); // only use static part
     // if (data.length === 82) return null; // token mint
     try {
         return AccountLayout$1.decode(data);
@@ -10358,7 +10359,8 @@ function parseMultipleAccounts(accounts) {
         let parsedSplAccount;
         if (account) {
             const owner = new PublicKey(account.owner);
-            if (owner.equals(TOKEN_PROGRAM_ID)) {
+            if (owner.equals(TOKEN_PROGRAM_ID) ||
+                owner.equals(TOKEN_2022_PROGRAM_ID)) {
                 if (account.data instanceof buffer.Buffer) {
                     parsedSplAccount = parseSplAccount(account.data);
                 }
@@ -10628,18 +10630,17 @@ const DefaultAccountStateLayout = struct$1([u8$1('state')]);
 DefaultAccountStateLayout.span;
 
 // src/codes.ts
-var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1 = 8078e3;
-var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1 = 8078001;
-var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1 = 8078004;
-var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1 = 8078005;
-var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1 = 8078006;
-var SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS$1 = 8078007;
-var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1 = 8078011;
+var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$2 = 8078e3;
+var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$2 = 8078001;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$2 = 8078004;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$2 = 8078005;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$2 = 8078006;
+var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$2 = 8078011;
 
 // src/context.ts
-function encodeValue$1(value) {
+function encodeValue$2(value) {
   if (Array.isArray(value)) {
-    const commaSeparatedValues = value.map(encodeValue$1).join(
+    const commaSeparatedValues = value.map(encodeValue$2).join(
       "%2C%20"
       /* ", " */
     );
@@ -10659,23 +10660,23 @@ function encodeValue$1(value) {
     );
   }
 }
-function encodeObjectContextEntry$1([key, value]) {
-  return `${key}=${encodeValue$1(value)}`;
+function encodeObjectContextEntry$2([key, value]) {
+  return `${key}=${encodeValue$2(value)}`;
 }
-function encodeContextObject$1(context) {
-  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry$1).join("&");
+function encodeContextObject$2(context) {
+  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry$2).join("&");
   return btoa(searchParamsString);
 }
-function getErrorMessage$1(code, context = {}) {
+function getErrorMessage$2(code, context = {}) {
   {
     let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
     if (Object.keys(context).length) {
-      decodingAdviceMessage += ` '${encodeContextObject$1(context)}'`;
+      decodingAdviceMessage += ` '${encodeContextObject$2(context)}'`;
     }
     return `${decodingAdviceMessage}\``;
   }
 }
-var SolanaError$1 = class extends Error {
+var SolanaError$2 = class extends Error {
   cause = this.cause;
   context;
   constructor(...[code, contextAndErrorOptions]) {
@@ -10690,7 +10691,7 @@ var SolanaError$1 = class extends Error {
         context = contextRest;
       }
     }
-    const message = getErrorMessage$1(code, context);
+    const message = getErrorMessage$2(code, context);
     super(message, errorOptions);
     this.context = {
       __code: code,
@@ -10700,47 +10701,47 @@ var SolanaError$1 = class extends Error {
   }
 };
 
-var padBytes$1 = (bytes, length) => {
+var padBytes$2 = (bytes, length) => {
   if (bytes.length >= length) return bytes;
   const paddedBytes = new Uint8Array(length).fill(0);
   paddedBytes.set(bytes);
   return paddedBytes;
 };
-var fixBytes$1 = (bytes, length) => padBytes$1(bytes.length <= length ? bytes : bytes.slice(0, length), length);
-function getEncodedSize$1(value, encoder) {
+var fixBytes$2 = (bytes, length) => padBytes$2(bytes.length <= length ? bytes : bytes.slice(0, length), length);
+function getEncodedSize$2(value, encoder) {
   return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
 }
-function createEncoder$1(encoder) {
+function createEncoder$2(encoder) {
   return Object.freeze({
     ...encoder,
     encode: (value) => {
-      const bytes = new Uint8Array(getEncodedSize$1(value, encoder));
+      const bytes = new Uint8Array(getEncodedSize$2(value, encoder));
       encoder.write(value, bytes, 0);
       return bytes;
     }
   });
 }
-function createDecoder$1(decoder) {
+function createDecoder$2(decoder) {
   return Object.freeze({
     ...decoder,
     decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
   });
 }
-function isFixedSize$1(codec) {
+function isFixedSize$2(codec) {
   return "fixedSize" in codec && typeof codec.fixedSize === "number";
 }
-function combineCodec$1(encoder, decoder) {
-  if (isFixedSize$1(encoder) !== isFixedSize$1(decoder)) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1);
+function combineCodec$2(encoder, decoder) {
+  if (isFixedSize$2(encoder) !== isFixedSize$2(decoder)) {
+    throw new SolanaError$2(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$2);
   }
-  if (isFixedSize$1(encoder) && isFixedSize$1(decoder) && encoder.fixedSize !== decoder.fixedSize) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1, {
+  if (isFixedSize$2(encoder) && isFixedSize$2(decoder) && encoder.fixedSize !== decoder.fixedSize) {
+    throw new SolanaError$2(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$2, {
       decoderFixedSize: decoder.fixedSize,
       encoderFixedSize: encoder.fixedSize
     });
   }
-  if (!isFixedSize$1(encoder) && !isFixedSize$1(decoder) && encoder.maxSize !== decoder.maxSize) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1, {
+  if (!isFixedSize$2(encoder) && !isFixedSize$2(decoder) && encoder.maxSize !== decoder.maxSize) {
+    throw new SolanaError$2(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$2, {
       decoderMaxSize: decoder.maxSize,
       encoderMaxSize: encoder.maxSize
     });
@@ -10754,17 +10755,17 @@ function combineCodec$1(encoder, decoder) {
     write: encoder.write
   };
 }
-function assertByteArrayIsNotEmptyForCodec$1(codecDescription, bytes, offset = 0) {
+function assertByteArrayIsNotEmptyForCodec$2(codecDescription, bytes, offset = 0) {
   if (bytes.length - offset <= 0) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1, {
+    throw new SolanaError$2(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$2, {
       codecDescription
     });
   }
 }
-function assertByteArrayHasEnoughBytesForCodec$1(codecDescription, expected, bytes, offset = 0) {
+function assertByteArrayHasEnoughBytesForCodec$2(codecDescription, expected, bytes, offset = 0) {
   const bytesLength = bytes.length - offset;
   if (bytesLength < expected) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1, {
+    throw new SolanaError$2(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$2, {
       bytesLength,
       codecDescription,
       expected
@@ -10772,56 +10773,9 @@ function assertByteArrayHasEnoughBytesForCodec$1(codecDescription, expected, byt
   }
 }
 
-// src/add-codec-size-prefix.ts
-function addEncoderSizePrefix(encoder, prefix) {
-  const write = (value, bytes, offset) => {
-    const encoderBytes = encoder.encode(value);
-    offset = prefix.write(encoderBytes.length, bytes, offset);
-    bytes.set(encoderBytes, offset);
-    return offset + encoderBytes.length;
-  };
-  if (isFixedSize$1(prefix) && isFixedSize$1(encoder)) {
-    return createEncoder$1({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
-  }
-  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
-  const encoderMaxSize = isFixedSize$1(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
-  const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
-  return createEncoder$1({
-    ...encoder,
-    ...maxSize !== null ? { maxSize } : {},
-    getSizeFromValue: (value) => {
-      const encoderSize = getEncodedSize$1(value, encoder);
-      return getEncodedSize$1(encoderSize, prefix) + encoderSize;
-    },
-    write
-  });
-}
-function addDecoderSizePrefix(decoder, prefix) {
-  const read = (bytes, offset) => {
-    const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
-    const size = Number(bigintSize);
-    offset = decoderOffset;
-    if (offset > 0 || bytes.length > size) {
-      bytes = bytes.slice(offset, offset + size);
-    }
-    assertByteArrayHasEnoughBytesForCodec$1("addDecoderSizePrefix", size, bytes);
-    return [decoder.decode(bytes), offset + size];
-  };
-  if (isFixedSize$1(prefix) && isFixedSize$1(decoder)) {
-    return createDecoder$1({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
-  }
-  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
-  const decoderMaxSize = isFixedSize$1(decoder) ? decoder.fixedSize : decoder.maxSize ?? null;
-  const maxSize = prefixMaxSize !== null && decoderMaxSize !== null ? prefixMaxSize + decoderMaxSize : null;
-  return createDecoder$1({ ...decoder, ...maxSize !== null ? { maxSize } : {}, read });
-}
-function addCodecSizePrefix(codec, prefix) {
-  return combineCodec$1(addEncoderSizePrefix(codec, prefix), addDecoderSizePrefix(codec, prefix));
-}
-
 // src/fix-codec-size.ts
-function fixEncoderSize$1(encoder, fixedBytes) {
-  return createEncoder$1({
+function fixEncoderSize$2(encoder, fixedBytes) {
+  return createEncoder$2({
     fixedSize: fixedBytes,
     write: (value, bytes, offset) => {
       const variableByteArray = encoder.encode(value);
@@ -10831,30 +10785,30 @@ function fixEncoderSize$1(encoder, fixedBytes) {
     }
   });
 }
-function fixDecoderSize$1(decoder, fixedBytes) {
-  return createDecoder$1({
+function fixDecoderSize$2(decoder, fixedBytes) {
+  return createDecoder$2({
     fixedSize: fixedBytes,
     read: (bytes, offset) => {
-      assertByteArrayHasEnoughBytesForCodec$1("fixCodecSize", fixedBytes, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec$2("fixCodecSize", fixedBytes, bytes, offset);
       if (offset > 0 || bytes.length > fixedBytes) {
         bytes = bytes.slice(offset, offset + fixedBytes);
       }
-      if (isFixedSize$1(decoder)) {
-        bytes = fixBytes$1(bytes, decoder.fixedSize);
+      if (isFixedSize$2(decoder)) {
+        bytes = fixBytes$2(bytes, decoder.fixedSize);
       }
       const [value] = decoder.read(bytes, 0);
       return [value, offset + fixedBytes];
     }
   });
 }
-function fixCodecSize$1(codec, fixedBytes) {
-  return combineCodec$1(fixEncoderSize$1(codec, fixedBytes), fixDecoderSize$1(codec, fixedBytes));
+function fixCodecSize$2(codec, fixedBytes) {
+  return combineCodec$2(fixEncoderSize$2(codec, fixedBytes), fixDecoderSize$2(codec, fixedBytes));
 }
 
 // src/assertions.ts
-function assertNumberIsBetweenForCodec$1(codecDescription, min, max, value) {
+function assertNumberIsBetweenForCodec$2(codecDescription, min, max, value) {
   if (value < min || value > max) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1, {
+    throw new SolanaError$2(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$2, {
       codecDescription,
       max,
       min,
@@ -10862,156 +10816,65 @@ function assertNumberIsBetweenForCodec$1(codecDescription, min, max, value) {
     });
   }
 }
-function isLittleEndian$1(config) {
+function isLittleEndian$2(config) {
   return config?.endian === 1 /* Big */ ? false : true;
 }
-function numberEncoderFactory$1(input) {
-  return createEncoder$1({
+function numberEncoderFactory$2(input) {
+  return createEncoder$2({
     fixedSize: input.size,
     write(value, bytes, offset) {
       if (input.range) {
-        assertNumberIsBetweenForCodec$1(input.name, input.range[0], input.range[1], value);
+        assertNumberIsBetweenForCodec$2(input.name, input.range[0], input.range[1], value);
       }
       const arrayBuffer = new ArrayBuffer(input.size);
-      input.set(new DataView(arrayBuffer), value, isLittleEndian$1(input.config));
+      input.set(new DataView(arrayBuffer), value, isLittleEndian$2(input.config));
       bytes.set(new Uint8Array(arrayBuffer), offset);
       return offset + input.size;
     }
   });
 }
-function numberDecoderFactory$1(input) {
-  return createDecoder$1({
+function numberDecoderFactory$2(input) {
+  return createDecoder$2({
     fixedSize: input.size,
     read(bytes, offset = 0) {
-      assertByteArrayIsNotEmptyForCodec$1(input.name, bytes, offset);
-      assertByteArrayHasEnoughBytesForCodec$1(input.name, input.size, bytes, offset);
-      const view = new DataView(toArrayBuffer$1(bytes, offset, input.size));
-      return [input.get(view, isLittleEndian$1(input.config)), offset + input.size];
+      assertByteArrayIsNotEmptyForCodec$2(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec$2(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer$2(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian$2(input.config)), offset + input.size];
     }
   });
 }
-function toArrayBuffer$1(bytes, offset, length) {
+function toArrayBuffer$2(bytes, offset, length) {
   const bytesOffset = bytes.byteOffset + (offset ?? 0);
   const bytesLength = length ?? bytes.byteLength;
   return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
 }
-var getU32Encoder$1 = (config = {}) => numberEncoderFactory$1({
-  config,
-  name: "u32",
-  range: [0, Number("0xffffffff")],
-  set: (view, value, le) => view.setUint32(0, Number(value), le),
-  size: 4
-});
-var getU32Decoder$1 = (config = {}) => numberDecoderFactory$1({
-  config,
-  get: (view, le) => view.getUint32(0, le),
-  name: "u32",
-  size: 4
-});
-var getU32Codec = (config = {}) => combineCodec$1(getU32Encoder$1(config), getU32Decoder$1(config));
-var getU64Encoder$1 = (config = {}) => numberEncoderFactory$1({
+var getU64Encoder$1 = (config = {}) => numberEncoderFactory$2({
   config,
   name: "u64",
   range: [0n, BigInt("0xffffffffffffffff")],
   set: (view, value, le) => view.setBigUint64(0, BigInt(value), le),
   size: 8
 });
-var getU64Decoder$1 = (config = {}) => numberDecoderFactory$1({
+var getU64Decoder$1 = (config = {}) => numberDecoderFactory$2({
   config,
   get: (view, le) => view.getBigUint64(0, le),
   name: "u64",
   size: 8
 });
-var getU64Codec$1 = (config = {}) => combineCodec$1(getU64Encoder$1(config), getU64Decoder$1(config));
+var getU64Codec$1 = (config = {}) => combineCodec$2(getU64Encoder$1(config), getU64Decoder$1(config));
 
-// src/array.ts
-function assertValidNumberOfItemsForCodec$1(codecDescription, expected, actual) {
-  if (expected !== actual) {
-    throw new SolanaError$1(SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS$1, {
-      actual,
-      codecDescription,
-      expected
-    });
-  }
-}
-function sumCodecSizes$1(sizes) {
+function sumCodecSizes$2(sizes) {
   return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
 }
-function getFixedSize$1(codec) {
-  return isFixedSize$1(codec) ? codec.fixedSize : null;
-}
-function getMaxSize$1(codec) {
-  return isFixedSize$1(codec) ? codec.fixedSize : codec.maxSize ?? null;
-}
-
-// src/array.ts
-function getArrayEncoder$1(item, config = {}) {
-  const size = config.size ?? getU32Encoder$1();
-  const fixedSize = computeArrayLikeCodecSize$1(size, getFixedSize$1(item));
-  const maxSize = computeArrayLikeCodecSize$1(size, getMaxSize$1(item)) ?? void 0;
-  return createEncoder$1({
-    ...fixedSize !== null ? { fixedSize } : {
-      getSizeFromValue: (array) => {
-        const prefixSize = typeof size === "object" ? getEncodedSize$1(array.length, size) : 0;
-        return prefixSize + [...array].reduce((all, value) => all + getEncodedSize$1(value, item), 0);
-      },
-      maxSize
-    },
-    write: (array, bytes, offset) => {
-      if (typeof size === "number") {
-        assertValidNumberOfItemsForCodec$1("array", size, array.length);
-      }
-      if (typeof size === "object") {
-        offset = size.write(array.length, bytes, offset);
-      }
-      array.forEach((value) => {
-        offset = item.write(value, bytes, offset);
-      });
-      return offset;
-    }
-  });
-}
-function getArrayDecoder$1(item, config = {}) {
-  const size = config.size ?? getU32Decoder$1();
-  const itemSize = getFixedSize$1(item);
-  const fixedSize = computeArrayLikeCodecSize$1(size, itemSize);
-  const maxSize = computeArrayLikeCodecSize$1(size, getMaxSize$1(item)) ?? void 0;
-  return createDecoder$1({
-    ...fixedSize !== null ? { fixedSize } : { maxSize },
-    read: (bytes, offset) => {
-      const array = [];
-      if (typeof size === "object" && bytes.slice(offset).length === 0) {
-        return [array, offset];
-      }
-      if (size === "remainder") {
-        while (offset < bytes.length) {
-          const [value, newOffset2] = item.read(bytes, offset);
-          offset = newOffset2;
-          array.push(value);
-        }
-        return [array, offset];
-      }
-      const [resolvedSize, newOffset] = typeof size === "number" ? [size, offset] : size.read(bytes, offset);
-      offset = newOffset;
-      for (let i = 0; i < resolvedSize; i += 1) {
-        const [value, newOffset2] = item.read(bytes, offset);
-        offset = newOffset2;
-        array.push(value);
-      }
-      return [array, offset];
-    }
-  });
-}
-function getArrayCodec$1(item, config = {}) {
-  return combineCodec$1(getArrayEncoder$1(item, config), getArrayDecoder$1(item, config));
+function getFixedSize$2(codec) {
+  return isFixedSize$2(codec) ? codec.fixedSize : null;
 }
-function computeArrayLikeCodecSize$1(size, itemSize) {
-  if (typeof size !== "number") return null;
-  if (size === 0) return 0;
-  return itemSize === null ? null : itemSize * size;
+function getMaxSize$2(codec) {
+  return isFixedSize$2(codec) ? codec.fixedSize : codec.maxSize ?? null;
 }
-function getBytesEncoder$1() {
-  return createEncoder$1({
+function getBytesEncoder$2() {
+  return createEncoder$2({
     getSizeFromValue: (value) => value.length,
     write: (value, bytes, offset) => {
       bytes.set(value, offset);
@@ -11019,63 +10882,24 @@ function getBytesEncoder$1() {
     }
   });
 }
-function getBytesDecoder$1() {
-  return createDecoder$1({
+function getBytesDecoder$2() {
+  return createDecoder$2({
     read: (bytes, offset) => {
       const slice = bytes.slice(offset);
       return [slice, offset + slice.length];
     }
   });
 }
-function getBytesCodec$1() {
-  return combineCodec$1(getBytesEncoder$1(), getBytesDecoder$1());
-}
-function getTupleEncoder$1(items) {
-  const fixedSize = sumCodecSizes$1(items.map(getFixedSize$1));
-  const maxSize = sumCodecSizes$1(items.map(getMaxSize$1)) ?? void 0;
-  return createEncoder$1({
-    ...fixedSize === null ? {
-      getSizeFromValue: (value) => items.map((item, index) => getEncodedSize$1(value[index], item)).reduce((all, one) => all + one, 0),
-      maxSize
-    } : { fixedSize },
-    write: (value, bytes, offset) => {
-      assertValidNumberOfItemsForCodec$1("tuple", items.length, value.length);
-      items.forEach((item, index) => {
-        offset = item.write(value[index], bytes, offset);
-      });
-      return offset;
-    }
-  });
-}
-function getTupleDecoder$1(items) {
-  const fixedSize = sumCodecSizes$1(items.map(getFixedSize$1));
-  const maxSize = sumCodecSizes$1(items.map(getMaxSize$1)) ?? void 0;
-  return createDecoder$1({
-    ...fixedSize === null ? { maxSize } : { fixedSize },
-    read: (bytes, offset) => {
-      const values = [];
-      items.forEach((item) => {
-        const [newValue, newOffset] = item.read(bytes, offset);
-        values.push(newValue);
-        offset = newOffset;
-      });
-      return [values, offset];
-    }
-  });
-}
-function getTupleCodec$1(items) {
-  return combineCodec$1(
-    getTupleEncoder$1(items),
-    getTupleDecoder$1(items)
-  );
+function getBytesCodec$2() {
+  return combineCodec$2(getBytesEncoder$2(), getBytesDecoder$2());
 }
-function getStructEncoder$1(fields) {
+function getStructEncoder$2(fields) {
   const fieldCodecs = fields.map(([, codec]) => codec);
-  const fixedSize = sumCodecSizes$1(fieldCodecs.map(getFixedSize$1));
-  const maxSize = sumCodecSizes$1(fieldCodecs.map(getMaxSize$1)) ?? void 0;
-  return createEncoder$1({
+  const fixedSize = sumCodecSizes$2(fieldCodecs.map(getFixedSize$2));
+  const maxSize = sumCodecSizes$2(fieldCodecs.map(getMaxSize$2)) ?? void 0;
+  return createEncoder$2({
     ...fixedSize === null ? {
-      getSizeFromValue: (value) => fields.map(([key, codec]) => getEncodedSize$1(value[key], codec)).reduce((all, one) => all + one, 0),
+      getSizeFromValue: (value) => fields.map(([key, codec]) => getEncodedSize$2(value[key], codec)).reduce((all, one) => all + one, 0),
       maxSize
     } : { fixedSize },
     write: (struct, bytes, offset) => {
@@ -11086,11 +10910,11 @@ function getStructEncoder$1(fields) {
     }
   });
 }
-function getStructDecoder$1(fields) {
+function getStructDecoder$2(fields) {
   const fieldCodecs = fields.map(([, codec]) => codec);
-  const fixedSize = sumCodecSizes$1(fieldCodecs.map(getFixedSize$1));
-  const maxSize = sumCodecSizes$1(fieldCodecs.map(getMaxSize$1)) ?? void 0;
-  return createDecoder$1({
+  const fixedSize = sumCodecSizes$2(fieldCodecs.map(getFixedSize$2));
+  const maxSize = sumCodecSizes$2(fieldCodecs.map(getMaxSize$2)) ?? void 0;
+  return createDecoder$2({
     ...fixedSize === null ? { maxSize } : { fixedSize },
     read: (bytes, offset) => {
       const struct = {};
@@ -11103,57 +10927,24 @@ function getStructDecoder$1(fields) {
     }
   });
 }
-function getStructCodec$1(fields) {
-  return combineCodec$1(
-    getStructEncoder$1(fields),
-    getStructDecoder$1(fields)
+function getStructCodec$2(fields) {
+  return combineCodec$2(
+    getStructEncoder$2(fields),
+    getStructDecoder$2(fields)
   );
 }
 
-// src/null-characters.ts
-var removeNullCharacters$1 = (value) => (
-  // eslint-disable-next-line no-control-regex
-  value.replace(/\u0000/g, "")
-);
-
-// ../text-encoding-impl/dist/index.browser.mjs
-var e$1 = globalThis.TextDecoder;
-var o$1 = globalThis.TextEncoder;
-
-// src/utf8.ts
-var getUtf8Encoder$1 = () => {
-  let textEncoder;
-  return createEncoder$1({
-    getSizeFromValue: (value) => (textEncoder ||= new o$1()).encode(value).length,
-    write: (value, bytes, offset) => {
-      const bytesToAdd = (textEncoder ||= new o$1()).encode(value);
-      bytes.set(bytesToAdd, offset);
-      return offset + bytesToAdd.length;
-    }
-  });
-};
-var getUtf8Decoder$1 = () => {
-  let textDecoder;
-  return createDecoder$1({
-    read(bytes, offset) {
-      const value = (textDecoder ||= new e$1()).decode(bytes.slice(offset));
-      return [removeNullCharacters$1(value), bytes.length];
-    }
-  });
-};
-var getUtf8Codec$1 = () => combineCodec$1(getUtf8Encoder$1(), getUtf8Decoder$1());
-
-const tokenGroupCodec = getStructCodec$1([
-    ['updateAuthority', fixCodecSize$1(getBytesCodec$1(), 32)],
-    ['mint', fixCodecSize$1(getBytesCodec$1(), 32)],
+const tokenGroupCodec = getStructCodec$2([
+    ['updateAuthority', fixCodecSize$2(getBytesCodec$2(), 32)],
+    ['mint', fixCodecSize$2(getBytesCodec$2(), 32)],
     ['size', getU64Codec$1()],
     ['maxSize', getU64Codec$1()],
 ]);
 tokenGroupCodec.fixedSize;
 
-const tokenGroupMemberCodec = getStructCodec$1([
-    ['mint', fixCodecSize$1(getBytesCodec$1(), 32)],
-    ['group', fixCodecSize$1(getBytesCodec$1(), 32)],
+const tokenGroupMemberCodec = getStructCodec$2([
+    ['mint', fixCodecSize$2(getBytesCodec$2(), 32)],
+    ['group', fixCodecSize$2(getBytesCodec$2(), 32)],
     ['memberNumber', getU64Codec$1()],
 ]);
 tokenGroupMemberCodec.fixedSize;
@@ -11594,50 +11385,552 @@ struct$1([
     publicKey$4('groupAddress'),
 ]);
 
-/** TODO: docs */
-struct$1([
-    u8$1('instruction'),
-    u8$1('decimals'),
-    publicKey$4('mintAuthority'),
-    new COptionPublicKeyLayout('freezeAuthority'),
-]);
+/** TODO: docs */
+struct$1([
+    u8$1('instruction'),
+    u8$1('decimals'),
+    publicKey$4('mintAuthority'),
+    new COptionPublicKeyLayout('freezeAuthority'),
+]);
+
+var InterestBearingMintInstruction;
+(function (InterestBearingMintInstruction) {
+    InterestBearingMintInstruction[InterestBearingMintInstruction["Initialize"] = 0] = "Initialize";
+    InterestBearingMintInstruction[InterestBearingMintInstruction["UpdateRate"] = 1] = "UpdateRate";
+})(InterestBearingMintInstruction || (InterestBearingMintInstruction = {}));
+struct$1([
+    u8$1('instruction'),
+    u8$1('interestBearingMintInstruction'),
+    // TODO: Make this an optional public key
+    publicKey$4('rateAuthority'),
+    s16('rate'),
+]);
+struct$1([
+    u8$1('instruction'),
+    u8$1('interestBearingMintInstruction'),
+    s16('rate'),
+]);
+
+var MetadataPointerInstruction;
+(function (MetadataPointerInstruction) {
+    MetadataPointerInstruction[MetadataPointerInstruction["Initialize"] = 0] = "Initialize";
+    MetadataPointerInstruction[MetadataPointerInstruction["Update"] = 1] = "Update";
+})(MetadataPointerInstruction || (MetadataPointerInstruction = {}));
+struct$1([
+    // prettier-ignore
+    u8$1('instruction'),
+    u8$1('metadataPointerInstruction'),
+    publicKey$4('authority'),
+    publicKey$4('metadataAddress'),
+]);
+struct$1([
+    // prettier-ignore
+    u8$1('instruction'),
+    u8$1('metadataPointerInstruction'),
+    publicKey$4('metadataAddress'),
+]);
+
+// src/codes.ts
+var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1 = 8078e3;
+var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1 = 8078001;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1 = 8078004;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1 = 8078005;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1 = 8078006;
+var SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS$1 = 8078007;
+var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1 = 8078011;
+
+// src/context.ts
+function encodeValue$1(value) {
+  if (Array.isArray(value)) {
+    const commaSeparatedValues = value.map(encodeValue$1).join(
+      "%2C%20"
+      /* ", " */
+    );
+    return "%5B" + commaSeparatedValues + /* "]" */
+    "%5D";
+  } else if (typeof value === "bigint") {
+    return `${value}n`;
+  } else {
+    return encodeURIComponent(
+      String(
+        value != null && Object.getPrototypeOf(value) === null ? (
+          // Plain objects with no prototype don't have a `toString` method.
+          // Convert them before stringifying them.
+          { ...value }
+        ) : value
+      )
+    );
+  }
+}
+function encodeObjectContextEntry$1([key, value]) {
+  return `${key}=${encodeValue$1(value)}`;
+}
+function encodeContextObject$1(context) {
+  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry$1).join("&");
+  return btoa(searchParamsString);
+}
+function getErrorMessage$1(code, context = {}) {
+  {
+    let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
+    if (Object.keys(context).length) {
+      decodingAdviceMessage += ` '${encodeContextObject$1(context)}'`;
+    }
+    return `${decodingAdviceMessage}\``;
+  }
+}
+var SolanaError$1 = class extends Error {
+  cause = this.cause;
+  context;
+  constructor(...[code, contextAndErrorOptions]) {
+    let context;
+    let errorOptions;
+    if (contextAndErrorOptions) {
+      const { cause, ...contextRest } = contextAndErrorOptions;
+      if (cause) {
+        errorOptions = { cause };
+      }
+      if (Object.keys(contextRest).length > 0) {
+        context = contextRest;
+      }
+    }
+    const message = getErrorMessage$1(code, context);
+    super(message, errorOptions);
+    this.context = {
+      __code: code,
+      ...context
+    };
+    this.name = "SolanaError";
+  }
+};
+
+var padBytes$1 = (bytes, length) => {
+  if (bytes.length >= length) return bytes;
+  const paddedBytes = new Uint8Array(length).fill(0);
+  paddedBytes.set(bytes);
+  return paddedBytes;
+};
+var fixBytes$1 = (bytes, length) => padBytes$1(bytes.length <= length ? bytes : bytes.slice(0, length), length);
+function getEncodedSize$1(value, encoder) {
+  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+}
+function createEncoder$1(encoder) {
+  return Object.freeze({
+    ...encoder,
+    encode: (value) => {
+      const bytes = new Uint8Array(getEncodedSize$1(value, encoder));
+      encoder.write(value, bytes, 0);
+      return bytes;
+    }
+  });
+}
+function createDecoder$1(decoder) {
+  return Object.freeze({
+    ...decoder,
+    decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
+  });
+}
+function isFixedSize$1(codec) {
+  return "fixedSize" in codec && typeof codec.fixedSize === "number";
+}
+function combineCodec$1(encoder, decoder) {
+  if (isFixedSize$1(encoder) !== isFixedSize$1(decoder)) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH$1);
+  }
+  if (isFixedSize$1(encoder) && isFixedSize$1(decoder) && encoder.fixedSize !== decoder.fixedSize) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH$1, {
+      decoderFixedSize: decoder.fixedSize,
+      encoderFixedSize: encoder.fixedSize
+    });
+  }
+  if (!isFixedSize$1(encoder) && !isFixedSize$1(decoder) && encoder.maxSize !== decoder.maxSize) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH$1, {
+      decoderMaxSize: decoder.maxSize,
+      encoderMaxSize: encoder.maxSize
+    });
+  }
+  return {
+    ...decoder,
+    ...encoder,
+    decode: decoder.decode,
+    encode: encoder.encode,
+    read: decoder.read,
+    write: encoder.write
+  };
+}
+function assertByteArrayIsNotEmptyForCodec$1(codecDescription, bytes, offset = 0) {
+  if (bytes.length - offset <= 0) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY$1, {
+      codecDescription
+    });
+  }
+}
+function assertByteArrayHasEnoughBytesForCodec$1(codecDescription, expected, bytes, offset = 0) {
+  const bytesLength = bytes.length - offset;
+  if (bytesLength < expected) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH$1, {
+      bytesLength,
+      codecDescription,
+      expected
+    });
+  }
+}
+
+// src/add-codec-size-prefix.ts
+function addEncoderSizePrefix(encoder, prefix) {
+  const write = (value, bytes, offset) => {
+    const encoderBytes = encoder.encode(value);
+    offset = prefix.write(encoderBytes.length, bytes, offset);
+    bytes.set(encoderBytes, offset);
+    return offset + encoderBytes.length;
+  };
+  if (isFixedSize$1(prefix) && isFixedSize$1(encoder)) {
+    return createEncoder$1({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
+  }
+  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
+  const encoderMaxSize = isFixedSize$1(encoder) ? encoder.fixedSize : encoder.maxSize ?? null;
+  const maxSize = prefixMaxSize !== null && encoderMaxSize !== null ? prefixMaxSize + encoderMaxSize : null;
+  return createEncoder$1({
+    ...encoder,
+    ...maxSize !== null ? { maxSize } : {},
+    getSizeFromValue: (value) => {
+      const encoderSize = getEncodedSize$1(value, encoder);
+      return getEncodedSize$1(encoderSize, prefix) + encoderSize;
+    },
+    write
+  });
+}
+function addDecoderSizePrefix(decoder, prefix) {
+  const read = (bytes, offset) => {
+    const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
+    const size = Number(bigintSize);
+    offset = decoderOffset;
+    if (offset > 0 || bytes.length > size) {
+      bytes = bytes.slice(offset, offset + size);
+    }
+    assertByteArrayHasEnoughBytesForCodec$1("addDecoderSizePrefix", size, bytes);
+    return [decoder.decode(bytes), offset + size];
+  };
+  if (isFixedSize$1(prefix) && isFixedSize$1(decoder)) {
+    return createDecoder$1({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
+  }
+  const prefixMaxSize = isFixedSize$1(prefix) ? prefix.fixedSize : prefix.maxSize ?? null;
+  const decoderMaxSize = isFixedSize$1(decoder) ? decoder.fixedSize : decoder.maxSize ?? null;
+  const maxSize = prefixMaxSize !== null && decoderMaxSize !== null ? prefixMaxSize + decoderMaxSize : null;
+  return createDecoder$1({ ...decoder, ...maxSize !== null ? { maxSize } : {}, read });
+}
+function addCodecSizePrefix(codec, prefix) {
+  return combineCodec$1(addEncoderSizePrefix(codec, prefix), addDecoderSizePrefix(codec, prefix));
+}
+
+// src/fix-codec-size.ts
+function fixEncoderSize$1(encoder, fixedBytes) {
+  return createEncoder$1({
+    fixedSize: fixedBytes,
+    write: (value, bytes, offset) => {
+      const variableByteArray = encoder.encode(value);
+      const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
+      bytes.set(fixedByteArray, offset);
+      return offset + fixedBytes;
+    }
+  });
+}
+function fixDecoderSize$1(decoder, fixedBytes) {
+  return createDecoder$1({
+    fixedSize: fixedBytes,
+    read: (bytes, offset) => {
+      assertByteArrayHasEnoughBytesForCodec$1("fixCodecSize", fixedBytes, bytes, offset);
+      if (offset > 0 || bytes.length > fixedBytes) {
+        bytes = bytes.slice(offset, offset + fixedBytes);
+      }
+      if (isFixedSize$1(decoder)) {
+        bytes = fixBytes$1(bytes, decoder.fixedSize);
+      }
+      const [value] = decoder.read(bytes, 0);
+      return [value, offset + fixedBytes];
+    }
+  });
+}
+function fixCodecSize$1(codec, fixedBytes) {
+  return combineCodec$1(fixEncoderSize$1(codec, fixedBytes), fixDecoderSize$1(codec, fixedBytes));
+}
+
+// src/assertions.ts
+function assertNumberIsBetweenForCodec$1(codecDescription, min, max, value) {
+  if (value < min || value > max) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE$1, {
+      codecDescription,
+      max,
+      min,
+      value
+    });
+  }
+}
+function isLittleEndian$1(config) {
+  return config?.endian === 1 /* Big */ ? false : true;
+}
+function numberEncoderFactory$1(input) {
+  return createEncoder$1({
+    fixedSize: input.size,
+    write(value, bytes, offset) {
+      if (input.range) {
+        assertNumberIsBetweenForCodec$1(input.name, input.range[0], input.range[1], value);
+      }
+      const arrayBuffer = new ArrayBuffer(input.size);
+      input.set(new DataView(arrayBuffer), value, isLittleEndian$1(input.config));
+      bytes.set(new Uint8Array(arrayBuffer), offset);
+      return offset + input.size;
+    }
+  });
+}
+function numberDecoderFactory$1(input) {
+  return createDecoder$1({
+    fixedSize: input.size,
+    read(bytes, offset = 0) {
+      assertByteArrayIsNotEmptyForCodec$1(input.name, bytes, offset);
+      assertByteArrayHasEnoughBytesForCodec$1(input.name, input.size, bytes, offset);
+      const view = new DataView(toArrayBuffer$1(bytes, offset, input.size));
+      return [input.get(view, isLittleEndian$1(input.config)), offset + input.size];
+    }
+  });
+}
+function toArrayBuffer$1(bytes, offset, length) {
+  const bytesOffset = bytes.byteOffset + (offset ?? 0);
+  const bytesLength = length ?? bytes.byteLength;
+  return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
+}
+var getU32Encoder$1 = (config = {}) => numberEncoderFactory$1({
+  config,
+  name: "u32",
+  range: [0, Number("0xffffffff")],
+  set: (view, value, le) => view.setUint32(0, Number(value), le),
+  size: 4
+});
+var getU32Decoder$1 = (config = {}) => numberDecoderFactory$1({
+  config,
+  get: (view, le) => view.getUint32(0, le),
+  name: "u32",
+  size: 4
+});
+var getU32Codec = (config = {}) => combineCodec$1(getU32Encoder$1(config), getU32Decoder$1(config));
+
+// src/array.ts
+function assertValidNumberOfItemsForCodec$1(codecDescription, expected, actual) {
+  if (expected !== actual) {
+    throw new SolanaError$1(SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS$1, {
+      actual,
+      codecDescription,
+      expected
+    });
+  }
+}
+function sumCodecSizes$1(sizes) {
+  return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
+}
+function getFixedSize$1(codec) {
+  return isFixedSize$1(codec) ? codec.fixedSize : null;
+}
+function getMaxSize$1(codec) {
+  return isFixedSize$1(codec) ? codec.fixedSize : codec.maxSize ?? null;
+}
+
+// src/array.ts
+function getArrayEncoder$1(item, config = {}) {
+  const size = config.size ?? getU32Encoder$1();
+  const fixedSize = computeArrayLikeCodecSize$1(size, getFixedSize$1(item));
+  const maxSize = computeArrayLikeCodecSize$1(size, getMaxSize$1(item)) ?? void 0;
+  return createEncoder$1({
+    ...fixedSize !== null ? { fixedSize } : {
+      getSizeFromValue: (array) => {
+        const prefixSize = typeof size === "object" ? getEncodedSize$1(array.length, size) : 0;
+        return prefixSize + [...array].reduce((all, value) => all + getEncodedSize$1(value, item), 0);
+      },
+      maxSize
+    },
+    write: (array, bytes, offset) => {
+      if (typeof size === "number") {
+        assertValidNumberOfItemsForCodec$1("array", size, array.length);
+      }
+      if (typeof size === "object") {
+        offset = size.write(array.length, bytes, offset);
+      }
+      array.forEach((value) => {
+        offset = item.write(value, bytes, offset);
+      });
+      return offset;
+    }
+  });
+}
+function getArrayDecoder$1(item, config = {}) {
+  const size = config.size ?? getU32Decoder$1();
+  const itemSize = getFixedSize$1(item);
+  const fixedSize = computeArrayLikeCodecSize$1(size, itemSize);
+  const maxSize = computeArrayLikeCodecSize$1(size, getMaxSize$1(item)) ?? void 0;
+  return createDecoder$1({
+    ...fixedSize !== null ? { fixedSize } : { maxSize },
+    read: (bytes, offset) => {
+      const array = [];
+      if (typeof size === "object" && bytes.slice(offset).length === 0) {
+        return [array, offset];
+      }
+      if (size === "remainder") {
+        while (offset < bytes.length) {
+          const [value, newOffset2] = item.read(bytes, offset);
+          offset = newOffset2;
+          array.push(value);
+        }
+        return [array, offset];
+      }
+      const [resolvedSize, newOffset] = typeof size === "number" ? [size, offset] : size.read(bytes, offset);
+      offset = newOffset;
+      for (let i = 0; i < resolvedSize; i += 1) {
+        const [value, newOffset2] = item.read(bytes, offset);
+        offset = newOffset2;
+        array.push(value);
+      }
+      return [array, offset];
+    }
+  });
+}
+function getArrayCodec$1(item, config = {}) {
+  return combineCodec$1(getArrayEncoder$1(item, config), getArrayDecoder$1(item, config));
+}
+function computeArrayLikeCodecSize$1(size, itemSize) {
+  if (typeof size !== "number") return null;
+  if (size === 0) return 0;
+  return itemSize === null ? null : itemSize * size;
+}
+function getBytesEncoder$1() {
+  return createEncoder$1({
+    getSizeFromValue: (value) => value.length,
+    write: (value, bytes, offset) => {
+      bytes.set(value, offset);
+      return offset + value.length;
+    }
+  });
+}
+function getBytesDecoder$1() {
+  return createDecoder$1({
+    read: (bytes, offset) => {
+      const slice = bytes.slice(offset);
+      return [slice, offset + slice.length];
+    }
+  });
+}
+function getBytesCodec$1() {
+  return combineCodec$1(getBytesEncoder$1(), getBytesDecoder$1());
+}
+function getTupleEncoder$1(items) {
+  const fixedSize = sumCodecSizes$1(items.map(getFixedSize$1));
+  const maxSize = sumCodecSizes$1(items.map(getMaxSize$1)) ?? void 0;
+  return createEncoder$1({
+    ...fixedSize === null ? {
+      getSizeFromValue: (value) => items.map((item, index) => getEncodedSize$1(value[index], item)).reduce((all, one) => all + one, 0),
+      maxSize
+    } : { fixedSize },
+    write: (value, bytes, offset) => {
+      assertValidNumberOfItemsForCodec$1("tuple", items.length, value.length);
+      items.forEach((item, index) => {
+        offset = item.write(value[index], bytes, offset);
+      });
+      return offset;
+    }
+  });
+}
+function getTupleDecoder$1(items) {
+  const fixedSize = sumCodecSizes$1(items.map(getFixedSize$1));
+  const maxSize = sumCodecSizes$1(items.map(getMaxSize$1)) ?? void 0;
+  return createDecoder$1({
+    ...fixedSize === null ? { maxSize } : { fixedSize },
+    read: (bytes, offset) => {
+      const values = [];
+      items.forEach((item) => {
+        const [newValue, newOffset] = item.read(bytes, offset);
+        values.push(newValue);
+        offset = newOffset;
+      });
+      return [values, offset];
+    }
+  });
+}
+function getTupleCodec$1(items) {
+  return combineCodec$1(
+    getTupleEncoder$1(items),
+    getTupleDecoder$1(items)
+  );
+}
+function getStructEncoder$1(fields) {
+  const fieldCodecs = fields.map(([, codec]) => codec);
+  const fixedSize = sumCodecSizes$1(fieldCodecs.map(getFixedSize$1));
+  const maxSize = sumCodecSizes$1(fieldCodecs.map(getMaxSize$1)) ?? void 0;
+  return createEncoder$1({
+    ...fixedSize === null ? {
+      getSizeFromValue: (value) => fields.map(([key, codec]) => getEncodedSize$1(value[key], codec)).reduce((all, one) => all + one, 0),
+      maxSize
+    } : { fixedSize },
+    write: (struct, bytes, offset) => {
+      fields.forEach(([key, codec]) => {
+        offset = codec.write(struct[key], bytes, offset);
+      });
+      return offset;
+    }
+  });
+}
+function getStructDecoder$1(fields) {
+  const fieldCodecs = fields.map(([, codec]) => codec);
+  const fixedSize = sumCodecSizes$1(fieldCodecs.map(getFixedSize$1));
+  const maxSize = sumCodecSizes$1(fieldCodecs.map(getMaxSize$1)) ?? void 0;
+  return createDecoder$1({
+    ...fixedSize === null ? { maxSize } : { fixedSize },
+    read: (bytes, offset) => {
+      const struct = {};
+      fields.forEach(([key, codec]) => {
+        const [value, newOffset] = codec.read(bytes, offset);
+        offset = newOffset;
+        struct[key] = value;
+      });
+      return [struct, offset];
+    }
+  });
+}
+function getStructCodec$1(fields) {
+  return combineCodec$1(
+    getStructEncoder$1(fields),
+    getStructDecoder$1(fields)
+  );
+}
+
+// src/null-characters.ts
+var removeNullCharacters$1 = (value) => (
+  // eslint-disable-next-line no-control-regex
+  value.replace(/\u0000/g, "")
+);
 
-var InterestBearingMintInstruction;
-(function (InterestBearingMintInstruction) {
-    InterestBearingMintInstruction[InterestBearingMintInstruction["Initialize"] = 0] = "Initialize";
-    InterestBearingMintInstruction[InterestBearingMintInstruction["UpdateRate"] = 1] = "UpdateRate";
-})(InterestBearingMintInstruction || (InterestBearingMintInstruction = {}));
-struct$1([
-    u8$1('instruction'),
-    u8$1('interestBearingMintInstruction'),
-    // TODO: Make this an optional public key
-    publicKey$4('rateAuthority'),
-    s16('rate'),
-]);
-struct$1([
-    u8$1('instruction'),
-    u8$1('interestBearingMintInstruction'),
-    s16('rate'),
-]);
+// ../text-encoding-impl/dist/index.browser.mjs
+var e$1 = globalThis.TextDecoder;
+var o$1 = globalThis.TextEncoder;
 
-var MetadataPointerInstruction;
-(function (MetadataPointerInstruction) {
-    MetadataPointerInstruction[MetadataPointerInstruction["Initialize"] = 0] = "Initialize";
-    MetadataPointerInstruction[MetadataPointerInstruction["Update"] = 1] = "Update";
-})(MetadataPointerInstruction || (MetadataPointerInstruction = {}));
-struct$1([
-    // prettier-ignore
-    u8$1('instruction'),
-    u8$1('metadataPointerInstruction'),
-    publicKey$4('authority'),
-    publicKey$4('metadataAddress'),
-]);
-struct$1([
-    // prettier-ignore
-    u8$1('instruction'),
-    u8$1('metadataPointerInstruction'),
-    publicKey$4('metadataAddress'),
-]);
+// src/utf8.ts
+var getUtf8Encoder$1 = () => {
+  let textEncoder;
+  return createEncoder$1({
+    getSizeFromValue: (value) => (textEncoder ||= new o$1()).encode(value).length,
+    write: (value, bytes, offset) => {
+      const bytesToAdd = (textEncoder ||= new o$1()).encode(value);
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
+};
+var getUtf8Decoder$1 = () => {
+  let textDecoder;
+  return createDecoder$1({
+    read(bytes, offset) {
+      const value = (textDecoder ||= new e$1()).decode(bytes.slice(offset));
+      return [removeNullCharacters$1(value), bytes.length];
+    }
+  });
+};
+var getUtf8Codec$1 = () => combineCodec$1(getUtf8Encoder$1(), getUtf8Decoder$1());
 
 var Field;
 (function (Field) {
@@ -14615,23 +14908,7 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	    return (mod && mod.__esModule) ? mod : { "default": mod };
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.struct = exports.f64 = exports.f32 = exports.i32 = exports.u32 = exports.i16 = exports.u16 = exports.i8 = exports.u8 = void 0;
-	exports.u64 = u64;
-	exports.i64 = i64;
-	exports.u128 = u128;
-	exports.i128 = i128;
-	exports.u256 = u256;
-	exports.i256 = i256;
-	exports.publicKey = publicKey;
-	exports.option = option;
-	exports.bool = bool;
-	exports.vec = vec;
-	exports.tagged = tagged;
-	exports.vecU8 = vecU8;
-	exports.str = str;
-	exports.rustEnum = rustEnum;
-	exports.array = array;
-	exports.map = map;
+	exports.map = exports.array = exports.rustEnum = exports.str = exports.vecU8 = exports.tagged = exports.vec = exports.bool = exports.option = exports.publicKey = exports.i256 = exports.u256 = exports.i128 = exports.u128 = exports.i64 = exports.u64 = exports.struct = exports.f64 = exports.f32 = exports.i32 = exports.u32 = exports.i16 = exports.u16 = exports.i8 = exports.u8 = void 0;
 	const buffer_layout_1 = Layout$2;
 	const web3_js_1 = require$$1;
 	const bn_js_1 = __importDefault(bn.exports);
@@ -14668,21 +14945,27 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	function u64(property) {
 	    return new BNLayout(8, false, property);
 	}
+	exports.u64 = u64;
 	function i64(property) {
 	    return new BNLayout(8, true, property);
 	}
+	exports.i64 = i64;
 	function u128(property) {
 	    return new BNLayout(16, false, property);
 	}
+	exports.u128 = u128;
 	function i128(property) {
 	    return new BNLayout(16, true, property);
 	}
+	exports.i128 = i128;
 	function u256(property) {
 	    return new BNLayout(32, false, property);
 	}
+	exports.u256 = u256;
 	function i256(property) {
 	    return new BNLayout(32, true, property);
 	}
+	exports.i256 = i256;
 	class WrappedLayout extends buffer_layout_1.Layout {
 	    constructor(layout, decoder, encoder, property) {
 	        super(layout.span, property);
@@ -14703,6 +14986,7 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	function publicKey(property) {
 	    return new WrappedLayout((0, buffer_layout_1.blob)(32), (b) => new web3_js_1.PublicKey(b), (key) => key.toBuffer(), property);
 	}
+	exports.publicKey = publicKey;
 	class OptionLayout extends buffer_layout_1.Layout {
 	    constructor(layout, property) {
 	        super(-1, property);
@@ -14740,9 +15024,11 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	function option(layout, property) {
 	    return new OptionLayout(layout, property);
 	}
+	exports.option = option;
 	function bool(property) {
 	    return new WrappedLayout((0, buffer_layout_1.u8)(), decodeBool, encodeBool, property);
 	}
+	exports.bool = bool;
 	function decodeBool(value) {
 	    if (value === 0) {
 	        return false;
@@ -14763,6 +15049,7 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	    ]);
 	    return new WrappedLayout(layout, ({ values }) => values, (values) => ({ values }), property);
 	}
+	exports.vec = vec;
 	function tagged(tag, layout, property) {
 	    const wrappedLayout = (0, buffer_layout_1.struct)([
 	        u64("tag"),
@@ -14779,6 +15066,7 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	    }
 	    return new WrappedLayout(wrappedLayout, decodeTag, (data) => ({ tag, data }), property);
 	}
+	exports.tagged = tagged;
 	function vecU8(property) {
 	    const length = (0, buffer_layout_1.u32)("length");
 	    const layout = (0, buffer_layout_1.struct)([
@@ -14787,20 +15075,24 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	    ]);
 	    return new WrappedLayout(layout, ({ data }) => data, (data) => ({ data }), property);
 	}
+	exports.vecU8 = vecU8;
 	function str(property) {
 	    return new WrappedLayout(vecU8(), (data) => data.toString("utf-8"), (s) => Buffer.from(s, "utf-8"), property);
 	}
+	exports.str = str;
 	function rustEnum(variants, property, discriminant) {
 	    const unionLayout = (0, buffer_layout_1.union)(discriminant !== null && discriminant !== void 0 ? discriminant : (0, buffer_layout_1.u8)(), property);
 	    variants.forEach((variant, index) => unionLayout.addVariant(index, variant, variant.property));
 	    return unionLayout;
 	}
+	exports.rustEnum = rustEnum;
 	function array(elementLayout, length, property) {
 	    const layout = (0, buffer_layout_1.struct)([
 	        (0, buffer_layout_1.seq)(elementLayout, length, "values"),
 	    ]);
 	    return new WrappedLayout(layout, ({ values }) => values, (values) => ({ values }), property);
 	}
+	exports.array = array;
 	class MapEntryLayout extends buffer_layout_1.Layout {
 	    constructor(keyLayout, valueLayout, property) {
 	        super(keyLayout.span + valueLayout.span, property);
@@ -14831,6 +15123,7 @@ Layout$2.const = ((value, property) => new Constant(value, property));
 	    ]);
 	    return new WrappedLayout(layout, ({ values }) => new Map(values), (values) => ({ values: Array.from(values.entries()) }), property);
 	}
+	exports.map = map;
 	
 } (dist$1));