@solana/compat 2.0.0-experimental.f7d1af1 → 2.0.0-experimental.fafdfb2

package/dist/index.native.js

@@ -1,3 +1,5 @@
+import { createKeyPairFromBytes } from '@solana/keys';
+import { SolanaError, SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER, SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_NO_INSTRUCTIONS, SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_NOT_ADVANCE_NONCE, SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE, SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE, SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS, SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE } from '@solana/errors';
 import { pipe } from '@solana/functional';
 import { AccountRole } from '@solana/instructions';
 import { createTransaction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, appendTransactionInstruction, isAdvanceNonceAccountInstruction, setTransactionLifetimeUsingDurableNonce } from '@solana/transactions';
@@ -6,115 +8,83 @@ import { createTransaction, setTransactionFeePayer, setTransactionLifetimeUsingB
 function fromLegacyPublicKey(publicKey) {
   return publicKey.toBase58();
 }
-
-// src/keypair.ts
-function addPkcs8Header(bytes) {
-  return new Uint8Array([
-    /**
-     * PKCS#8 header
-     */
-    48,
-    // ASN.1 sequence tag
-    46,
-    // Length of sequence (46 more bytes)
-    2,
-    // ASN.1 integer tag
-    1,
-    // Length of integer
-    0,
-    // Version number
-    48,
-    // ASN.1 sequence tag
-    5,
-    // Length of sequence
-    6,
-    // ASN.1 object identifier tag
-    3,
-    // Length of object identifier
-    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
-    43,
-    // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
-    101,
-    // thawte(101)
-    // Ed25519 identifier
-    112,
-    // id-Ed25519(112)
-    /**
-     * Private key payload
-     */
-    4,
-    // ASN.1 octet string tag
-    34,
-    // String length (34 more bytes)
-    // Private key bytes as octet string
-    4,
-    // ASN.1 octet string tag
-    32,
-    // String length (32 bytes)
-    ...bytes
-  ]);
-}
 async function fromLegacyKeypair(keypair, extractable) {
-  const publicKey = await crypto.subtle.importKey("raw", keypair.publicKey.toBytes(), "Ed25519", true, [
-    "verify"
-  ]);
-  const privateKeyBytesPkcs8 = addPkcs8Header(keypair.secretKey.slice(0, 32));
-  const privateKey = await crypto.subtle.importKey(
-    "pkcs8",
-    privateKeyBytesPkcs8,
-    "Ed25519",
-    extractable ?? false,
-    ["sign"]
+  const bytes = new Uint8Array(64);
+  bytes.set(keypair.secretKey);
+  bytes.set(
+    keypair.publicKey.toBytes(),
+    /* offset */
+    32
   );
-  return {
-    privateKey,
-    publicKey
-  };
+  return createKeyPairFromBytes(bytes, extractable);
+}
+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}].`);
+    throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {
+      alphabet: alphabet4,
+      base: alphabet4.length,
+      value: givenValue
+    });
   }
 }
 var getBaseXEncoder = (alphabet4) => {
-  const base = alphabet4.length;
-  const baseBigInt = BigInt(base);
-  return {
-    description: `base${base}`,
-    encode(value) {
+  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 new Uint8Array();
-      const chars = [...value];
-      let trailIndex = chars.findIndex((c) => c !== alphabet4[0]);
-      trailIndex = trailIndex === -1 ? chars.length : trailIndex;
-      const leadingZeroes = Array(trailIndex).fill(0);
-      if (trailIndex === chars.length)
-        return Uint8Array.from(leadingZeroes);
-      const tailChars = chars.slice(trailIndex);
-      let base10Number = 0n;
-      let baseXPower = 1n;
-      for (let i = tailChars.length - 1; i >= 0; i -= 1) {
-        base10Number += baseXPower * BigInt(alphabet4.indexOf(tailChars[i]));
-        baseXPower *= baseBigInt;
+        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;
       }
-      return Uint8Array.from(leadingZeroes.concat(tailBytes));
-    },
-    fixedSize: null,
-    maxSize: null
-  };
+      const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
 };
+function partitionLeadingZeroes(value, zeroCharacter) {
+  const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));
+  return [leadingZeros, tailChars];
+}
+function getBigIntFromBaseX(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  let sum = 0n;
+  for (const char of value) {
+    sum *= base;
+    sum += BigInt(alphabet4.indexOf(char));
+  }
+  return sum;
+}
 var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 var getBase58Encoder = () => getBaseXEncoder(alphabet2);
-
-// ../addresses/dist/index.browser.js
 var memoizedBase58Encoder;
 function getMemoizedBase58Encoder() {
   if (!memoizedBase58Encoder)
@@ -122,30 +92,30 @@ function getMemoizedBase58Encoder() {
   return memoizedBase58Encoder;
 }
 function assertIsAddress(putativeAddress) {
-  try {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeAddress.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const base58Encoder = getMemoizedBase58Encoder();
-    const bytes = base58Encoder.encode(putativeAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e2) {
-    throw new Error(`\`${putativeAddress}\` is not a base-58 encoded address`, {
-      cause: e2
+  if (
+    // Lowest address (32 bytes of zeroes)
+    putativeAddress.length < 32 || // Highest address (32 bytes of 255)
+    putativeAddress.length > 44
+  ) {
+    throw new SolanaError(SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE, {
+      actualLength: putativeAddress.length
+    });
+  }
+  const base58Encoder = getMemoizedBase58Encoder();
+  const bytes = base58Encoder.encode(putativeAddress);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 32) {
+    throw new SolanaError(SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE, {
+      actualLength: numBytes
     });
   }
 }
 function convertAccount(message, accountKeys, accountIndex) {
   const accountPublicKey = accountKeys.get(accountIndex);
   if (!accountPublicKey) {
-    throw new Error(`Could not find account address at index ${accountIndex}`);
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS, {
+      index: accountIndex
+    });
   }
   const isSigner = message.isAccountSigner(accountIndex);
   const isWritable = message.isAccountWritable(accountIndex);
@@ -158,7 +128,9 @@ function convertAccount(message, accountKeys, accountIndex) {
 function convertInstruction(message, accountKeys, instruction) {
   const programAddressPublicKey = accountKeys.get(instruction.programIdIndex);
   if (!programAddressPublicKey) {
-    throw new Error(`Could not find program address at index ${instruction.programIdIndex}`);
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS, {
+      index: instruction.programIdIndex
+    });
   }
   const accounts = instruction.accountKeyIndexes.map(
     (accountIndex) => convertAccount(message, accountKeys, accountIndex)
@@ -185,7 +157,7 @@ function fromVersionedTransactionWithBlockhash(transaction, lastValidBlockHeight
   const accountKeys = transaction.message.getAccountKeys();
   const feePayer = accountKeys.staticAccountKeys[0];
   if (!feePayer)
-    throw new Error("No fee payer set in VersionedTransaction");
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER);
   const blockhashLifetime = {
     blockhash: transaction.message.recentBlockhash,
     lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
@@ -212,15 +184,15 @@ function fromVersionedTransactionWithDurableNonce(transaction) {
   const accountKeys = transaction.message.getAccountKeys();
   const feePayer = accountKeys.staticAccountKeys[0];
   if (!feePayer)
-    throw new Error("No fee payer set in VersionedTransaction");
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER);
   const instructions = transaction.message.compiledInstructions.map(
     (instruction) => convertInstruction(transaction.message, accountKeys, instruction)
   );
   if (instructions.length === 0) {
-    throw new Error("transaction with no instructions cannot be durable nonce transaction");
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_NO_INSTRUCTIONS);
   }
   if (!isAdvanceNonceAccountInstruction(instructions[0])) {
-    throw new Error("transaction first instruction is not advance nonce account instruction");
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_NOT_ADVANCE_NONCE);
   }
   const nonceAccountAddress = instructions[0].accounts[0].address;
   assertIsAddress(nonceAccountAddress);

package/dist/index.native.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/address.ts","../src/keypair.ts","../../codecs-strings/dist/index.browser.js","../../addresses/dist/index.browser.js","../src/transaction.ts"],"names":["e"],"mappings":"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","sourcesContent":["import { Address } from '@solana/addresses';\nimport { PublicKey } from '@solana/web3.js';\n\n/**\n * Convert from a Legacy Web3 JS PublicKey to a base58 encoded address\n * @param publicKey The PublicKey to convert\n * @returns         An Address\n */\nexport function fromLegacyPublicKey<TAddress extends string>(publicKey: PublicKey): Address<TAddress> {\n    return publicKey.toBase58() as Address<TAddress>;\n}\n","import { Keypair } from '@solana/web3.js';\n\nfunction addPkcs8Header(bytes: Uint8Array): Uint8Array {\n    // prettier-ignore\n    return new Uint8Array([\n        /**\n         * PKCS#8 header\n         */\n        0x30, // ASN.1 sequence tag\n        0x2e, // Length of sequence (46 more bytes)\n\n            0x02, // ASN.1 integer tag\n            0x01, // Length of integer\n                0x00, // Version number\n\n            0x30, // ASN.1 sequence tag\n            0x05, // Length of sequence\n                0x06, // ASN.1 object identifier tag\n                0x03, // Length of object identifier\n                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n                        0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n                        0x65, // thawte(101)\n                    // Ed25519 identifier\n                        0x70, // id-Ed25519(112)\n\n        /**\n         * Private key payload\n         */\n        0x04, // ASN.1 octet string tag\n        0x22, // String length (34 more bytes)\n\n            // Private key bytes as octet string\n            0x04, // ASN.1 octet string tag\n            0x20, // String length (32 bytes)\n\n        ...bytes\n    ]);\n}\n\n/**\n * Convert from a Legacy Web3 JS Keypair to a CryptoKeyPair\n * @param keypair   The Keypair to convert\n * @returns         A CryptoKeyPair\n */\nexport async function fromLegacyKeypair(keypair: Keypair, extractable?: boolean): Promise<CryptoKeyPair> {\n    const publicKey: CryptoKey = await crypto.subtle.importKey('raw', keypair.publicKey.toBytes(), 'Ed25519', true, [\n        'verify',\n    ]);\n    const privateKeyBytesPkcs8 = addPkcs8Header(keypair.secretKey.slice(0, 32));\n    const privateKey: CryptoKey = await crypto.subtle.importKey(\n        'pkcs8',\n        privateKeyBytesPkcs8,\n        'Ed25519',\n        extractable ?? false,\n        ['sign']\n    );\n    return {\n        privateKey,\n        publicKey,\n    } as CryptoKeyPair;\n}\n","import { combineCodec, fixEncoder, mergeBytes, fixDecoder, assertByteArrayIsNotEmptyForCodec, assertByteArrayHasEnoughBytesForCodec } from '@solana/codecs-core';\nimport { getU32Encoder, getU32Decoder } from '@solana/codecs-numbers';\n\n// src/assertions.ts\nfunction assertValidBaseString(alphabet4, testValue, givenValue = testValue) {\n  if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {\n    throw new Error(`Expected a string of base ${alphabet4.length}, got [${givenValue}].`);\n  }\n}\nvar getBaseXEncoder = (alphabet4) => {\n  const base = alphabet4.length;\n  const baseBigInt = BigInt(base);\n  return {\n    description: `base${base}`,\n    encode(value) {\n      assertValidBaseString(alphabet4, value);\n      if (value === \"\")\n        return new Uint8Array();\n      const chars = [...value];\n      let trailIndex = chars.findIndex((c) => c !== alphabet4[0]);\n      trailIndex = trailIndex === -1 ? chars.length : trailIndex;\n      const leadingZeroes = Array(trailIndex).fill(0);\n      if (trailIndex === chars.length)\n        return Uint8Array.from(leadingZeroes);\n      const tailChars = chars.slice(trailIndex);\n      let base10Number = 0n;\n      let baseXPower = 1n;\n      for (let i = tailChars.length - 1; i >= 0; i -= 1) {\n        base10Number += baseXPower * BigInt(alphabet4.indexOf(tailChars[i]));\n        baseXPower *= baseBigInt;\n      }\n      const tailBytes = [];\n      while (base10Number > 0n) {\n        tailBytes.unshift(Number(base10Number % 256n));\n        base10Number /= 256n;\n      }\n      return Uint8Array.from(leadingZeroes.concat(tailBytes));\n    },\n    fixedSize: null,\n    maxSize: null\n  };\n};\nvar getBaseXDecoder = (alphabet4) => {\n  const base = alphabet4.length;\n  const baseBigInt = BigInt(base);\n  return {\n    decode(rawBytes, offset = 0) {\n      const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n      if (bytes.length === 0)\n        return [\"\", 0];\n      let trailIndex = bytes.findIndex((n) => n !== 0);\n      trailIndex = trailIndex === -1 ? bytes.length : trailIndex;\n      const leadingZeroes = alphabet4[0].repeat(trailIndex);\n      if (trailIndex === bytes.length)\n        return [leadingZeroes, rawBytes.length];\n      let base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);\n      const tailChars = [];\n      while (base10Number > 0n) {\n        tailChars.unshift(alphabet4[Number(base10Number % baseBigInt)]);\n        base10Number /= baseBigInt;\n      }\n      return [leadingZeroes + tailChars.join(\"\"), rawBytes.length];\n    },\n    description: `base${base}`,\n    fixedSize: null,\n    maxSize: null\n  };\n};\nvar getBaseXCodec = (alphabet4) => combineCodec(getBaseXEncoder(alphabet4), getBaseXDecoder(alphabet4));\n\n// src/base10.ts\nvar alphabet = \"0123456789\";\nvar getBase10Encoder = () => getBaseXEncoder(alphabet);\nvar getBase10Decoder = () => getBaseXDecoder(alphabet);\nvar getBase10Codec = () => getBaseXCodec(alphabet);\nvar getBase16Encoder = () => ({\n  description: \"base16\",\n  encode(value) {\n    const lowercaseValue = value.toLowerCase();\n    assertValidBaseString(\"0123456789abcdef\", lowercaseValue, value);\n    const matches = lowercaseValue.match(/.{1,2}/g);\n    return Uint8Array.from(matches ? matches.map((byte) => parseInt(byte, 16)) : []);\n  },\n  fixedSize: null,\n  maxSize: null\n});\nvar getBase16Decoder = () => ({\n  decode(bytes, offset = 0) {\n    const value = bytes.slice(offset).reduce((str, byte) => str + byte.toString(16).padStart(2, \"0\"), \"\");\n    return [value, bytes.length];\n  },\n  description: \"base16\",\n  fixedSize: null,\n  maxSize: null\n});\nvar getBase16Codec = () => combineCodec(getBase16Encoder(), getBase16Decoder());\n\n// src/base58.ts\nvar alphabet2 = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\";\nvar getBase58Encoder = () => getBaseXEncoder(alphabet2);\nvar getBase58Decoder = () => getBaseXDecoder(alphabet2);\nvar getBase58Codec = () => getBaseXCodec(alphabet2);\nvar getBaseXResliceEncoder = (alphabet4, bits) => ({\n  description: `base${alphabet4.length}`,\n  encode(value) {\n    assertValidBaseString(alphabet4, value);\n    if (value === \"\")\n      return new Uint8Array();\n    const charIndices = [...value].map((c) => alphabet4.indexOf(c));\n    return new Uint8Array(reslice(charIndices, bits, 8, false));\n  },\n  fixedSize: null,\n  maxSize: null\n});\nvar getBaseXResliceDecoder = (alphabet4, bits) => ({\n  decode(rawBytes, offset = 0) {\n    const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n    if (bytes.length === 0)\n      return [\"\", rawBytes.length];\n    const charIndices = reslice([...bytes], 8, bits, true);\n    return [charIndices.map((i) => alphabet4[i]).join(\"\"), rawBytes.length];\n  },\n  description: `base${alphabet4.length}`,\n  fixedSize: null,\n  maxSize: null\n});\nvar getBaseXResliceCodec = (alphabet4, bits) => combineCodec(getBaseXResliceEncoder(alphabet4, bits), getBaseXResliceDecoder(alphabet4, bits));\nfunction reslice(input, inputBits, outputBits, useRemainder) {\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}\nvar getBase64Encoder = () => {\n  {\n    return {\n      description: `base64`,\n      encode(value) {\n        try {\n          const bytes = atob(value).split(\"\").map((c) => c.charCodeAt(0));\n          return new Uint8Array(bytes);\n        } catch (e2) {\n          throw new Error(`Expected a string of base 64, got [${value}].`);\n        }\n      },\n      fixedSize: null,\n      maxSize: null\n    };\n  }\n};\nvar getBase64Decoder = () => {\n  {\n    return {\n      decode(bytes, offset = 0) {\n        const slice = bytes.slice(offset);\n        const value = btoa(String.fromCharCode(...slice));\n        return [value, bytes.length];\n      },\n      description: `base64`,\n      fixedSize: null,\n      maxSize: null\n    };\n  }\n};\nvar getBase64Codec = () => combineCodec(getBase64Encoder(), getBase64Decoder());\n\n// src/null-characters.ts\nvar removeNullCharacters = (value) => (\n  // eslint-disable-next-line no-control-regex\n  value.replace(/\\u0000/g, \"\")\n);\nvar padNullCharacters = (value, chars) => value.padEnd(chars, \"\\0\");\n\n// ../text-encoding-impl/dist/index.browser.js\nvar e = globalThis.TextDecoder;\nvar o = globalThis.TextEncoder;\n\n// src/utf8.ts\nvar getUtf8Encoder = () => {\n  let textEncoder;\n  return {\n    description: \"utf8\",\n    encode: (value) => new Uint8Array((textEncoder || (textEncoder = new o())).encode(value)),\n    fixedSize: null,\n    maxSize: null\n  };\n};\nvar getUtf8Decoder = () => {\n  let textDecoder;\n  return {\n    decode(bytes, offset = 0) {\n      const value = (textDecoder || (textDecoder = new e())).decode(bytes.slice(offset));\n      return [removeNullCharacters(value), bytes.length];\n    },\n    description: \"utf8\",\n    fixedSize: null,\n    maxSize: null\n  };\n};\nvar getUtf8Codec = () => combineCodec(getUtf8Encoder(), getUtf8Decoder());\n\n// src/string.ts\nvar getStringEncoder = (options = {}) => {\n  const size = options.size ?? getU32Encoder();\n  const encoding = options.encoding ?? getUtf8Encoder();\n  const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;\n  if (size === \"variable\") {\n    return { ...encoding, description };\n  }\n  if (typeof size === \"number\") {\n    return fixEncoder(encoding, size, description);\n  }\n  return {\n    description,\n    encode: (value) => {\n      const contentBytes = encoding.encode(value);\n      const lengthBytes = size.encode(contentBytes.length);\n      return mergeBytes([lengthBytes, contentBytes]);\n    },\n    fixedSize: null,\n    maxSize: null\n  };\n};\nvar getStringDecoder = (options = {}) => {\n  const size = options.size ?? getU32Decoder();\n  const encoding = options.encoding ?? getUtf8Decoder();\n  const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;\n  if (size === \"variable\") {\n    return { ...encoding, description };\n  }\n  if (typeof size === \"number\") {\n    return fixDecoder(encoding, size, description);\n  }\n  return {\n    decode: (bytes, offset = 0) => {\n      assertByteArrayIsNotEmptyForCodec(\"string\", bytes, offset);\n      const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);\n      const length = Number(lengthBigInt);\n      offset = lengthOffset;\n      const contentBytes = bytes.slice(offset, offset + length);\n      assertByteArrayHasEnoughBytesForCodec(\"string\", length, contentBytes);\n      const [value, contentOffset] = encoding.decode(contentBytes);\n      offset += contentOffset;\n      return [value, offset];\n    },\n    description,\n    fixedSize: null,\n    maxSize: null\n  };\n};\nvar getStringCodec = (options = {}) => combineCodec(getStringEncoder(options), getStringDecoder(options));\nfunction getSizeDescription(size) {\n  return typeof size === \"object\" ? size.description : `${size}`;\n}\n\nexport { assertValidBaseString, getBase10Codec, getBase10Decoder, getBase10Encoder, getBase16Codec, getBase16Decoder, getBase16Encoder, getBase58Codec, getBase58Decoder, getBase58Encoder, getBase64Codec, getBase64Decoder, getBase64Encoder, getBaseXCodec, getBaseXDecoder, getBaseXEncoder, getBaseXResliceCodec, getBaseXResliceDecoder, getBaseXResliceEncoder, getStringCodec, getStringDecoder, getStringEncoder, getUtf8Codec, getUtf8Decoder, getUtf8Encoder, padNullCharacters, removeNullCharacters };\n","import { mapEncoder, combineCodec } from '@solana/codecs-core';\nimport { getStringEncoder, getStringDecoder, getBase58Encoder, getBase58Decoder } from '@solana/codecs-strings';\nimport { assertKeyExporterIsAvailable, assertDigestCapabilityIsAvailable } from '@solana/assertions';\n\n// src/address.ts\nvar memoizedBase58Encoder;\nvar memoizedBase58Decoder;\nfunction getMemoizedBase58Encoder() {\n  if (!memoizedBase58Encoder)\n    memoizedBase58Encoder = getBase58Encoder();\n  return memoizedBase58Encoder;\n}\nfunction getMemoizedBase58Decoder() {\n  if (!memoizedBase58Decoder)\n    memoizedBase58Decoder = getBase58Decoder();\n  return memoizedBase58Decoder;\n}\nfunction isAddress(putativeAddress) {\n  if (\n    // Lowest address (32 bytes of zeroes)\n    putativeAddress.length < 32 || // Highest address (32 bytes of 255)\n    putativeAddress.length > 44\n  ) {\n    return false;\n  }\n  const base58Encoder = getMemoizedBase58Encoder();\n  const bytes = base58Encoder.encode(putativeAddress);\n  const numBytes = bytes.byteLength;\n  if (numBytes !== 32) {\n    return false;\n  }\n  return true;\n}\nfunction assertIsAddress(putativeAddress) {\n  try {\n    if (\n      // Lowest address (32 bytes of zeroes)\n      putativeAddress.length < 32 || // Highest address (32 bytes of 255)\n      putativeAddress.length > 44\n    ) {\n      throw new Error(\"Expected input string to decode to a byte array of length 32.\");\n    }\n    const base58Encoder = getMemoizedBase58Encoder();\n    const bytes = base58Encoder.encode(putativeAddress);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 32) {\n      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n    }\n  } catch (e) {\n    throw new Error(`\\`${putativeAddress}\\` is not a base-58 encoded address`, {\n      cause: e\n    });\n  }\n}\nfunction address(putativeAddress) {\n  assertIsAddress(putativeAddress);\n  return putativeAddress;\n}\nfunction getAddressEncoder(config) {\n  return mapEncoder(\n    getStringEncoder({\n      description: config?.description ?? \"Address\",\n      encoding: getMemoizedBase58Encoder(),\n      size: 32\n    }),\n    (putativeAddress) => address(putativeAddress)\n  );\n}\nfunction getAddressDecoder(config) {\n  return getStringDecoder({\n    description: config?.description ?? \"Address\",\n    encoding: getMemoizedBase58Decoder(),\n    size: 32\n  });\n}\nfunction getAddressCodec(config) {\n  return combineCodec(getAddressEncoder(config), getAddressDecoder(config));\n}\nfunction getAddressComparator() {\n  return new Intl.Collator(\"en\", {\n    caseFirst: \"lower\",\n    ignorePunctuation: false,\n    localeMatcher: \"best fit\",\n    numeric: false,\n    sensitivity: \"variant\",\n    usage: \"sort\"\n  }).compare;\n}\n\n// src/vendor/noble/ed25519.ts\nvar D = 37095705934669439343138083508754565189542113879843219016388785533085940283555n;\nvar P = 57896044618658097711785492504343953926634992332820282019728792003956564819949n;\nvar RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n;\nfunction mod(a) {\n  const r = a % P;\n  return r >= 0n ? r : P + r;\n}\nfunction pow2(x, power) {\n  let r = x;\n  while (power-- > 0n) {\n    r *= r;\n    r %= P;\n  }\n  return r;\n}\nfunction pow_2_252_3(x) {\n  const x2 = x * x % P;\n  const b2 = x2 * x % P;\n  const b4 = pow2(b2, 2n) * b2 % P;\n  const b5 = pow2(b4, 1n) * x % P;\n  const b10 = pow2(b5, 5n) * b5 % P;\n  const b20 = pow2(b10, 10n) * b10 % P;\n  const b40 = pow2(b20, 20n) * b20 % P;\n  const b80 = pow2(b40, 40n) * b40 % P;\n  const b160 = pow2(b80, 80n) * b80 % P;\n  const b240 = pow2(b160, 80n) * b80 % P;\n  const b250 = pow2(b240, 10n) * b10 % P;\n  const pow_p_5_8 = pow2(b250, 2n) * x % P;\n  return pow_p_5_8;\n}\nfunction uvRatio(u, v) {\n  const v3 = mod(v * v * v);\n  const v7 = mod(v3 * v3 * v);\n  const pow = pow_2_252_3(u * v7);\n  let x = mod(u * v3 * pow);\n  const vx2 = mod(v * x * x);\n  const root1 = x;\n  const root2 = mod(x * RM1);\n  const useRoot1 = vx2 === u;\n  const useRoot2 = vx2 === mod(-u);\n  const noRoot = vx2 === mod(-u * RM1);\n  if (useRoot1)\n    x = root1;\n  if (useRoot2 || noRoot)\n    x = root2;\n  if ((mod(x) & 1n) === 1n)\n    x = mod(-x);\n  if (!useRoot1 && !useRoot2) {\n    return null;\n  }\n  return x;\n}\nfunction pointIsOnCurve(y, lastByte) {\n  const y2 = mod(y * y);\n  const u = mod(y2 - 1n);\n  const v = mod(D * y2 + 1n);\n  const x = uvRatio(u, v);\n  if (x === null) {\n    return false;\n  }\n  const isLastByteOdd = (lastByte & 128) !== 0;\n  if (x === 0n && isLastByteOdd) {\n    return false;\n  }\n  return true;\n}\n\n// src/curve.ts\nfunction byteToHex(byte) {\n  const hexString = byte.toString(16);\n  if (hexString.length === 1) {\n    return `0${hexString}`;\n  } else {\n    return hexString;\n  }\n}\nfunction decompressPointBytes(bytes) {\n  const hexString = bytes.reduce((acc, byte, ii) => `${byteToHex(ii === 31 ? byte & ~128 : byte)}${acc}`, \"\");\n  const integerLiteralString = `0x${hexString}`;\n  return BigInt(integerLiteralString);\n}\nasync function compressedPointBytesAreOnCurve(bytes) {\n  if (bytes.byteLength !== 32) {\n    return false;\n  }\n  const y = decompressPointBytes(bytes);\n  return pointIsOnCurve(y, bytes[31]);\n}\n\n// src/program-derived-address.ts\nfunction isProgramDerivedAddress(value) {\n  return Array.isArray(value) && value.length === 2 && typeof value[0] === \"string\" && typeof value[1] === \"number\" && value[1] >= 0 && value[1] <= 255 && isAddress(value[0]);\n}\nfunction assertIsProgramDerivedAddress(value) {\n  const validFormat = Array.isArray(value) && value.length === 2 && typeof value[0] === \"string\" && typeof value[1] === \"number\";\n  if (!validFormat) {\n    throw new Error(\n      `Expected given program derived address to have the following format: [Address, ProgramDerivedAddressBump].`\n    );\n  }\n  if (value[1] < 0 || value[1] > 255) {\n    throw new Error(`Expected program derived address bump to be in the range [0, 255], got: ${value[1]}.`);\n  }\n  assertIsAddress(value[0]);\n}\nvar MAX_SEED_LENGTH = 32;\nvar MAX_SEEDS = 16;\nvar PDA_MARKER_BYTES = [\n  // The string 'ProgramDerivedAddress'\n  80,\n  114,\n  111,\n  103,\n  114,\n  97,\n  109,\n  68,\n  101,\n  114,\n  105,\n  118,\n  101,\n  100,\n  65,\n  100,\n  100,\n  114,\n  101,\n  115,\n  115\n];\nvar PointOnCurveError = class extends Error {\n};\nasync function createProgramDerivedAddress({ programAddress, seeds }) {\n  await assertDigestCapabilityIsAvailable();\n  if (seeds.length > MAX_SEEDS) {\n    throw new Error(`A maximum of ${MAX_SEEDS} seeds may be supplied when creating an address`);\n  }\n  let textEncoder;\n  const seedBytes = seeds.reduce((acc, seed, ii) => {\n    const bytes = typeof seed === \"string\" ? (textEncoder || (textEncoder = new TextEncoder())).encode(seed) : seed;\n    if (bytes.byteLength > MAX_SEED_LENGTH) {\n      throw new Error(`The seed at index ${ii} exceeds the maximum length of 32 bytes`);\n    }\n    acc.push(...bytes);\n    return acc;\n  }, []);\n  const base58EncodedAddressCodec = getAddressCodec();\n  const programAddressBytes = base58EncodedAddressCodec.encode(programAddress);\n  const addressBytesBuffer = await crypto.subtle.digest(\n    \"SHA-256\",\n    new Uint8Array([...seedBytes, ...programAddressBytes, ...PDA_MARKER_BYTES])\n  );\n  const addressBytes = new Uint8Array(addressBytesBuffer);\n  if (await compressedPointBytesAreOnCurve(addressBytes)) {\n    throw new PointOnCurveError(\"Invalid seeds; point must fall off the Ed25519 curve\");\n  }\n  return base58EncodedAddressCodec.decode(addressBytes)[0];\n}\nasync function getProgramDerivedAddress({\n  programAddress,\n  seeds\n}) {\n  let bumpSeed = 255;\n  while (bumpSeed > 0) {\n    try {\n      const address2 = await createProgramDerivedAddress({\n        programAddress,\n        seeds: [...seeds, new Uint8Array([bumpSeed])]\n      });\n      return [address2, bumpSeed];\n    } catch (e) {\n      if (e instanceof PointOnCurveError) {\n        bumpSeed--;\n      } else {\n        throw e;\n      }\n    }\n  }\n  throw new Error(\"Unable to find a viable program address bump seed\");\n}\nasync function createAddressWithSeed({ baseAddress, programAddress, seed }) {\n  const { encode, decode } = getAddressCodec();\n  const seedBytes = typeof seed === \"string\" ? new TextEncoder().encode(seed) : seed;\n  if (seedBytes.byteLength > MAX_SEED_LENGTH) {\n    throw new Error(`The seed exceeds the maximum length of 32 bytes`);\n  }\n  const programAddressBytes = encode(programAddress);\n  if (programAddressBytes.length >= PDA_MARKER_BYTES.length && programAddressBytes.slice(-PDA_MARKER_BYTES.length).every((byte, index) => byte === PDA_MARKER_BYTES[index])) {\n    throw new Error(`programAddress cannot end with the PDA marker`);\n  }\n  const addressBytesBuffer = await crypto.subtle.digest(\n    \"SHA-256\",\n    new Uint8Array([...encode(baseAddress), ...seedBytes, ...programAddressBytes])\n  );\n  const addressBytes = new Uint8Array(addressBytesBuffer);\n  return decode(addressBytes)[0];\n}\nasync function getAddressFromPublicKey(publicKey) {\n  await assertKeyExporterIsAvailable();\n  if (publicKey.type !== \"public\" || publicKey.algorithm.name !== \"Ed25519\") {\n    throw new Error(\"The `CryptoKey` must be an `Ed25519` public key\");\n  }\n  const publicKeyBytes = await crypto.subtle.exportKey(\"raw\", publicKey);\n  const [base58EncodedAddress] = getAddressDecoder().decode(new Uint8Array(publicKeyBytes));\n  return base58EncodedAddress;\n}\n\nexport { address, assertIsAddress, assertIsProgramDerivedAddress, createAddressWithSeed, getAddressCodec, getAddressComparator, getAddressDecoder, getAddressEncoder, getAddressFromPublicKey, getProgramDerivedAddress, isAddress, isProgramDerivedAddress };\n","import { type Address, assertIsAddress } from '@solana/addresses';\nimport { pipe } from '@solana/functional';\nimport type { IAccountMeta, IInstruction } from '@solana/instructions';\nimport { AccountRole } from '@solana/instructions';\nimport type { SignatureBytes } from '@solana/keys';\nimport {\n    appendTransactionInstruction,\n    type Blockhash,\n    createTransaction,\n    type IDurableNonceTransaction,\n    isAdvanceNonceAccountInstruction,\n    type ITransactionWithBlockhashLifetime,\n    type ITransactionWithFeePayer,\n    type ITransactionWithSignatures,\n    type Nonce,\n    setTransactionFeePayer,\n    setTransactionLifetimeUsingBlockhash,\n    setTransactionLifetimeUsingDurableNonce,\n    type Transaction,\n} from '@solana/transactions';\nimport type {\n    MessageAccountKeys,\n    MessageCompiledInstruction,\n    PublicKey,\n    VersionedMessage,\n    VersionedTransaction,\n} from '@solana/web3.js';\n\nfunction convertAccount(\n    message: VersionedMessage,\n    accountKeys: MessageAccountKeys,\n    accountIndex: number\n): IAccountMeta {\n    const accountPublicKey = accountKeys.get(accountIndex);\n    if (!accountPublicKey) {\n        // TODO coded error\n        throw new Error(`Could not find account address at index ${accountIndex}`);\n    }\n    const isSigner = message.isAccountSigner(accountIndex);\n    const isWritable = message.isAccountWritable(accountIndex);\n\n    const role = isSigner\n        ? isWritable\n            ? AccountRole.WRITABLE_SIGNER\n            : AccountRole.READONLY_SIGNER\n        : isWritable\n        ? AccountRole.WRITABLE\n        : AccountRole.READONLY;\n\n    return {\n        address: accountPublicKey.toBase58() as Address,\n        role,\n    };\n}\n\nfunction convertInstruction(\n    message: VersionedMessage,\n    accountKeys: MessageAccountKeys,\n    instruction: MessageCompiledInstruction\n): IInstruction {\n    const programAddressPublicKey = accountKeys.get(instruction.programIdIndex);\n    if (!programAddressPublicKey) {\n        // TODO coded error\n        throw new Error(`Could not find program address at index ${instruction.programIdIndex}`);\n    }\n\n    const accounts = instruction.accountKeyIndexes.map(accountIndex =>\n        convertAccount(message, accountKeys, accountIndex)\n    );\n\n    return {\n        programAddress: programAddressPublicKey.toBase58() as Address,\n        ...(accounts.length ? { accounts } : {}),\n        ...(instruction.data.length ? { data: instruction.data } : {}),\n    };\n}\n\nfunction convertSignatures(\n    transaction: VersionedTransaction,\n    staticAccountKeys: PublicKey[]\n): ITransactionWithSignatures['signatures'] {\n    return transaction.signatures.reduce((acc, sig, index) => {\n        // legacy web3js includes a fake all 0 signature if it hasn't been signed\n        // we don't do that for the new tx model. So just skip if it's all 0s\n        const allZeros = sig.every(byte => byte === 0);\n        if (allZeros) return acc;\n\n        const address = staticAccountKeys[index].toBase58() as Address;\n        return { ...acc, [address]: sig as SignatureBytes };\n    }, {});\n}\n\nexport function fromVersionedTransactionWithBlockhash(\n    transaction: VersionedTransaction,\n    lastValidBlockHeight?: bigint\n): Transaction & ITransactionWithFeePayer & ITransactionWithBlockhashLifetime {\n    // TODO: add support for address table lookups\n    // - will need to take `AddressLookupTableAccounts[]` as input\n    // - will need to convert account instructions to `IAccountLookupMeta` when appropriate\n    if (transaction.message.addressTableLookups.length > 0) {\n        // TODO coded error\n        throw new Error('Cannot convert transaction with addressTableLookups');\n    }\n\n    const accountKeys = transaction.message.getAccountKeys();\n\n    // Fee payer is first account\n    const feePayer = accountKeys.staticAccountKeys[0];\n    // TODO: coded error\n    if (!feePayer) throw new Error('No fee payer set in VersionedTransaction');\n\n    const blockhashLifetime = {\n        blockhash: transaction.message.recentBlockhash as Blockhash,\n        lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n, // U64 MAX\n    };\n\n    const instructions = transaction.message.compiledInstructions.map(instruction =>\n        convertInstruction(transaction.message, accountKeys, instruction)\n    );\n\n    const signatures = convertSignatures(transaction, accountKeys.staticAccountKeys);\n\n    return pipe(\n        createTransaction({ version: transaction.version }),\n        tx => setTransactionFeePayer(feePayer.toBase58() as Address, tx),\n        tx => setTransactionLifetimeUsingBlockhash(blockhashLifetime, tx),\n        tx =>\n            instructions.reduce((acc, instruction) => {\n                return appendTransactionInstruction(instruction, acc);\n            }, tx),\n        tx => (transaction.signatures.length ? { ...tx, signatures } : tx)\n    );\n}\n\nexport function fromVersionedTransactionWithDurableNonce(\n    transaction: VersionedTransaction\n): Transaction & ITransactionWithFeePayer & IDurableNonceTransaction {\n    // TODO: add support for address table lookups\n    // - will need to take `AddressLookupTableAccounts[]` as input\n    // - will need to convert account instructions to `IAccountLookupMeta` when appropriate\n    if (transaction.message.addressTableLookups.length > 0) {\n        // TODO coded error\n        throw new Error('Cannot convert transaction with addressTableLookups');\n    }\n\n    const accountKeys = transaction.message.getAccountKeys();\n\n    // Fee payer is first account\n    const feePayer = accountKeys.staticAccountKeys[0];\n    // TODO: coded error\n    if (!feePayer) throw new Error('No fee payer set in VersionedTransaction');\n\n    const instructions = transaction.message.compiledInstructions.map(instruction =>\n        convertInstruction(transaction.message, accountKeys, instruction)\n    );\n\n    // Check first instruction is durable nonce + extract params\n    if (instructions.length === 0) {\n        // TODO: coded error\n        throw new Error('transaction with no instructions cannot be durable nonce transaction');\n    }\n\n    if (!isAdvanceNonceAccountInstruction(instructions[0])) {\n        // TODO: coded error\n        throw new Error('transaction first instruction is not advance nonce account instruction');\n    }\n\n    // We know these accounts are defined because we checked `isAdvanceNonceAccountInstruction`\n    const nonceAccountAddress = instructions[0].accounts![0].address;\n    assertIsAddress(nonceAccountAddress);\n\n    const nonceAuthorityAddress = instructions[0].accounts![2].address;\n    assertIsAddress(nonceAuthorityAddress);\n\n    const durableNonceLifetime = {\n        nonce: transaction.message.recentBlockhash as Nonce,\n        nonceAccountAddress,\n        nonceAuthorityAddress,\n    };\n\n    const signatures = convertSignatures(transaction, accountKeys.staticAccountKeys);\n\n    return pipe(\n        createTransaction({ version: transaction.version }),\n        tx => setTransactionFeePayer(feePayer.toBase58() as Address, tx),\n        tx => setTransactionLifetimeUsingDurableNonce(durableNonceLifetime, tx),\n        tx =>\n            instructions.slice(1).reduce((acc, instruction) => {\n                return appendTransactionInstruction(instruction, acc);\n            }, tx),\n        tx => (transaction.signatures.length ? { ...tx, signatures } : tx)\n    );\n}\n"]}
+{"version":3,"sources":["../src/address.ts","../src/keypair.ts","../../codecs-core/src/bytes.ts","../../codecs-core/src/codec.ts","../../codecs-strings/src/assertions.ts","../../codecs-strings/src/baseX.ts","../../codecs-strings/src/base16.ts","../../codecs-strings/src/base64.ts","../../addresses/src/address.ts","../src/transaction.ts"],"names":["SolanaError","alphabet"],"mappings":"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","sourcesContent":["import { Address } from '@solana/addresses';\nimport { PublicKey } from '@solana/web3.js';\n\n/**\n * Convert from a Legacy Web3 JS PublicKey to a base58 encoded address\n * @param publicKey The PublicKey to convert\n * @returns         An Address\n */\nexport function fromLegacyPublicKey<TAddress extends string>(publicKey: PublicKey): Address<TAddress> {\n    return publicKey.toBase58() as Address<TAddress>;\n}\n","import { createKeyPairFromBytes } from '@solana/keys';\nimport { Keypair } from '@solana/web3.js';\n\n/**\n * Convert from a Legacy Web3 JS Keypair to a CryptoKeyPair\n * @param keypair   The Keypair to convert\n * @returns         A CryptoKeyPair\n */\nexport async function fromLegacyKeypair(keypair: Keypair, extractable?: boolean): Promise<CryptoKeyPair> {\n    const bytes = new Uint8Array(64);\n    bytes.set(keypair.secretKey);\n    bytes.set(keypair.publicKey.toBytes(), /* offset */ 32);\n    return createKeyPairFromBytes(bytes, extractable);\n}\n","/**\n * Concatenates an array of `Uint8Array`s into a single `Uint8Array`.\n * Reuses the original byte array when applicable.\n */\nexport const mergeBytes = (byteArrays: Uint8Array[]): Uint8Array => {\n    const nonEmptyByteArrays = byteArrays.filter(arr => arr.length);\n    if (nonEmptyByteArrays.length === 0) {\n        return byteArrays.length ? byteArrays[0] : new Uint8Array();\n    }\n\n    if (nonEmptyByteArrays.length === 1) {\n        return nonEmptyByteArrays[0];\n    }\n\n    const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);\n    const result = new Uint8Array(totalLength);\n    let offset = 0;\n    nonEmptyByteArrays.forEach(arr => {\n        result.set(arr, offset);\n        offset += arr.length;\n    });\n    return result;\n};\n\n/**\n * Pads a `Uint8Array` with zeroes to the specified length.\n * If the array is longer than the specified length, it is returned as-is.\n */\nexport const padBytes = (bytes: Uint8Array, length: number): Uint8Array => {\n    if (bytes.length >= length) return bytes;\n    const paddedBytes = new Uint8Array(length).fill(0);\n    paddedBytes.set(bytes);\n    return paddedBytes;\n};\n\n/**\n * Fixes a `Uint8Array` to the specified length.\n * If the array is longer than the specified length, it is truncated.\n * If the array is shorter than the specified length, it is padded with zeroes.\n */\nexport const fixBytes = (bytes: Uint8Array, length: number): Uint8Array =>\n    padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);\n","import {\n    SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH,\n    SOLANA_ERROR__CODECS_EXPECTED_VARIABLE_LENGTH_GOT_FIXED_LENGTH,\n    SolanaError,\n} from '@solana/errors';\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): asserts encoder is FixedSizeEncoder<TFrom, TSize>;\nexport function assertIsFixedSize<TTo, TSize extends number>(\n    decoder: FixedSizeDecoder<TTo, TSize> | VariableSizeDecoder<TTo>,\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): asserts codec is FixedSizeCodec<TFrom, TTo, TSize>;\nexport function assertIsFixedSize<TSize extends number>(\n    codec: { fixedSize: TSize } | { maxSize?: number },\n): asserts codec is { fixedSize: TSize };\nexport function assertIsFixedSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n): asserts codec is { fixedSize: number } {\n    if (!isFixedSize(codec)) {\n        throw new SolanaError(SOLANA_ERROR__CODECS_EXPECTED_FIXED_LENGTH_GOT_VARIABLE_LENGTH);\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>(encoder: Encoder<T>): asserts encoder is VariableSizeEncoder<T>;\nexport function assertIsVariableSize<T>(decoder: Decoder<T>): asserts decoder is VariableSizeDecoder<T>;\nexport function assertIsVariableSize<TFrom, TTo extends TFrom>(\n    codec: Codec<TFrom, TTo>,\n): asserts codec is VariableSizeCodec<TFrom, TTo>;\nexport function assertIsVariableSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n): asserts codec is { maxSize?: number };\nexport function assertIsVariableSize(\n    codec: { fixedSize: number } | { maxSize?: number },\n): asserts codec is { maxSize?: number } {\n    if (!isVariableSize(codec)) {\n        throw new SolanaError(SOLANA_ERROR__CODECS_EXPECTED_VARIABLE_LENGTH_GOT_FIXED_LENGTH);\n    }\n}\n","import { SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, SolanaError } from '@solana/errors';\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        throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {\n            alphabet,\n            base: alphabet.length,\n            value: givenValue,\n        });\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(\n    value: string,\n    zeroCharacter: string,\n): [leadingZeros: string, tailChars: string | undefined] {\n    const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));\n    return [leadingZeros, tailChars];\n}\n\nfunction getBigIntFromBaseX(value: string, alphabet: string): bigint {\n    const base = BigInt(alphabet.length);\n    let sum = 0n;\n    for (const char of value) {\n        sum *= base;\n        sum += BigInt(alphabet.indexOf(char));\n    }\n    return sum;\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    mapDecoder,\n    mapEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\nimport { SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, SolanaError } from '@solana/errors';\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                    throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {\n                        alphabet,\n                        base: 64,\n                        value,\n                    });\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                    throw new SolanaError(SOLANA_ERROR__CODECS_INVALID_STRING_FOR_BASE, {\n                        alphabet,\n                        base: 64,\n                        value,\n                    });\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 {\n    combineCodec,\n    Decoder,\n    Encoder,\n    FixedSizeCodec,\n    FixedSizeDecoder,\n    FixedSizeEncoder,\n    mapEncoder,\n} from '@solana/codecs-core';\nimport { getBase58Decoder, getBase58Encoder, getStringDecoder, getStringEncoder } from '@solana/codecs-strings';\nimport {\n    SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE,\n    SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE,\n    SolanaError,\n} from '@solana/errors';\n\nexport type Address<TAddress extends string = string> = TAddress & {\n    readonly __brand: unique symbol;\n};\n\nlet memoizedBase58Encoder: Encoder<string> | undefined;\nlet memoizedBase58Decoder: Decoder<string> | undefined;\n\nfunction getMemoizedBase58Encoder(): Encoder<string> {\n    if (!memoizedBase58Encoder) memoizedBase58Encoder = getBase58Encoder();\n    return memoizedBase58Encoder;\n}\n\nfunction getMemoizedBase58Decoder(): Decoder<string> {\n    if (!memoizedBase58Decoder) memoizedBase58Decoder = getBase58Decoder();\n    return memoizedBase58Decoder;\n}\n\nexport function isAddress(putativeAddress: string): putativeAddress is Address<typeof putativeAddress> {\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest address (32 bytes of zeroes)\n        putativeAddress.length < 32 ||\n        // Highest address (32 bytes of 255)\n        putativeAddress.length > 44\n    ) {\n        return false;\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const base58Encoder = getMemoizedBase58Encoder();\n    const bytes = base58Encoder.encode(putativeAddress);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 32) {\n        return false;\n    }\n    return true;\n}\n\nexport function assertIsAddress(putativeAddress: string): asserts putativeAddress is Address<typeof putativeAddress> {\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest address (32 bytes of zeroes)\n        putativeAddress.length < 32 ||\n        // Highest address (32 bytes of 255)\n        putativeAddress.length > 44\n    ) {\n        throw new SolanaError(SOLANA_ERROR__ADDRESS_STRING_LENGTH_OUT_OF_RANGE, {\n            actualLength: putativeAddress.length,\n        });\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const base58Encoder = getMemoizedBase58Encoder();\n    const bytes = base58Encoder.encode(putativeAddress);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 32) {\n        throw new SolanaError(SOLANA_ERROR__ADDRESS_BYTE_LENGTH_OUT_OF_RANGE, {\n            actualLength: numBytes,\n        });\n    }\n}\n\nexport function address<TAddress extends string = string>(putativeAddress: TAddress): Address<TAddress> {\n    assertIsAddress(putativeAddress);\n    return putativeAddress as Address<TAddress>;\n}\n\nexport function getAddressEncoder(): FixedSizeEncoder<Address, 32> {\n    return mapEncoder(getStringEncoder({ encoding: getMemoizedBase58Encoder(), size: 32 }), putativeAddress =>\n        address(putativeAddress),\n    );\n}\n\nexport function getAddressDecoder(): FixedSizeDecoder<Address, 32> {\n    return getStringDecoder({ encoding: getMemoizedBase58Decoder(), size: 32 }) as FixedSizeDecoder<Address, 32>;\n}\n\nexport function getAddressCodec(): FixedSizeCodec<Address, Address, 32> {\n    return combineCodec(getAddressEncoder(), getAddressDecoder());\n}\n\nexport function getAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n","import { type Address, assertIsAddress } from '@solana/addresses';\nimport {\n    SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_NOT_ADVANCE_NONCE,\n    SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_NO_INSTRUCTIONS,\n    SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS,\n    SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER,\n    SolanaError,\n} from '@solana/errors';\nimport { pipe } from '@solana/functional';\nimport type { IAccountMeta, IInstruction } from '@solana/instructions';\nimport { AccountRole } from '@solana/instructions';\nimport type { SignatureBytes } from '@solana/keys';\nimport type { Blockhash } from '@solana/rpc-types';\nimport {\n    appendTransactionInstruction,\n    createTransaction,\n    type IDurableNonceTransaction,\n    isAdvanceNonceAccountInstruction,\n    type ITransactionWithBlockhashLifetime,\n    type ITransactionWithFeePayer,\n    type ITransactionWithSignatures,\n    type Nonce,\n    setTransactionFeePayer,\n    setTransactionLifetimeUsingBlockhash,\n    setTransactionLifetimeUsingDurableNonce,\n    type Transaction,\n} from '@solana/transactions';\nimport type {\n    MessageAccountKeys,\n    MessageCompiledInstruction,\n    PublicKey,\n    VersionedMessage,\n    VersionedTransaction,\n} from '@solana/web3.js';\n\nfunction convertAccount(\n    message: VersionedMessage,\n    accountKeys: MessageAccountKeys,\n    accountIndex: number,\n): IAccountMeta {\n    const accountPublicKey = accountKeys.get(accountIndex);\n    if (!accountPublicKey) {\n        throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS, {\n            index: accountIndex,\n        });\n    }\n    const isSigner = message.isAccountSigner(accountIndex);\n    const isWritable = message.isAccountWritable(accountIndex);\n\n    const role = isSigner\n        ? isWritable\n            ? AccountRole.WRITABLE_SIGNER\n            : AccountRole.READONLY_SIGNER\n        : isWritable\n          ? AccountRole.WRITABLE\n          : AccountRole.READONLY;\n\n    return {\n        address: accountPublicKey.toBase58() as Address,\n        role,\n    };\n}\n\nfunction convertInstruction(\n    message: VersionedMessage,\n    accountKeys: MessageAccountKeys,\n    instruction: MessageCompiledInstruction,\n): IInstruction {\n    const programAddressPublicKey = accountKeys.get(instruction.programIdIndex);\n    if (!programAddressPublicKey) {\n        throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_ADDRESS, {\n            index: instruction.programIdIndex,\n        });\n    }\n\n    const accounts = instruction.accountKeyIndexes.map(accountIndex =>\n        convertAccount(message, accountKeys, accountIndex),\n    );\n\n    return {\n        programAddress: programAddressPublicKey.toBase58() as Address,\n        ...(accounts.length ? { accounts } : {}),\n        ...(instruction.data.length ? { data: instruction.data } : {}),\n    };\n}\n\nfunction convertSignatures(\n    transaction: VersionedTransaction,\n    staticAccountKeys: PublicKey[],\n): ITransactionWithSignatures['signatures'] {\n    return transaction.signatures.reduce((acc, sig, index) => {\n        // legacy web3js includes a fake all 0 signature if it hasn't been signed\n        // we don't do that for the new tx model. So just skip if it's all 0s\n        const allZeros = sig.every(byte => byte === 0);\n        if (allZeros) return acc;\n\n        const address = staticAccountKeys[index].toBase58() as Address;\n        return { ...acc, [address]: sig as SignatureBytes };\n    }, {});\n}\n\nexport function fromVersionedTransactionWithBlockhash(\n    transaction: VersionedTransaction,\n    lastValidBlockHeight?: bigint,\n): Transaction & ITransactionWithFeePayer & ITransactionWithBlockhashLifetime {\n    // TODO: add support for address table lookups\n    // - will need to take `AddressLookupTableAccounts[]` as input\n    // - will need to convert account instructions to `IAccountLookupMeta` when appropriate\n    if (transaction.message.addressTableLookups.length > 0) {\n        // TODO coded error\n        // This should probably not be a `SolanaError`, since we need to add\n        // this functionality.\n        throw new Error('Cannot convert transaction with addressTableLookups');\n    }\n\n    const accountKeys = transaction.message.getAccountKeys();\n\n    // Fee payer is first account\n    const feePayer = accountKeys.staticAccountKeys[0];\n    if (!feePayer) throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER);\n\n    const blockhashLifetime = {\n        blockhash: transaction.message.recentBlockhash as Blockhash,\n        lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n, // U64 MAX\n    };\n\n    const instructions = transaction.message.compiledInstructions.map(instruction =>\n        convertInstruction(transaction.message, accountKeys, instruction),\n    );\n\n    const signatures = convertSignatures(transaction, accountKeys.staticAccountKeys);\n\n    return pipe(\n        createTransaction({ version: transaction.version }),\n        tx => setTransactionFeePayer(feePayer.toBase58() as Address, tx),\n        tx => setTransactionLifetimeUsingBlockhash(blockhashLifetime, tx),\n        tx =>\n            instructions.reduce((acc, instruction) => {\n                return appendTransactionInstruction(instruction, acc);\n            }, tx),\n        tx => (transaction.signatures.length ? { ...tx, signatures } : tx),\n    );\n}\n\nexport function fromVersionedTransactionWithDurableNonce(\n    transaction: VersionedTransaction,\n): Transaction & ITransactionWithFeePayer & IDurableNonceTransaction {\n    // TODO: add support for address table lookups\n    // - will need to take `AddressLookupTableAccounts[]` as input\n    // - will need to convert account instructions to `IAccountLookupMeta` when appropriate\n    if (transaction.message.addressTableLookups.length > 0) {\n        // TODO coded error\n        // This should probably not be a `SolanaError`, since we need to add\n        // this functionality.\n        throw new Error('Cannot convert transaction with addressTableLookups');\n    }\n\n    const accountKeys = transaction.message.getAccountKeys();\n\n    // Fee payer is first account\n    const feePayer = accountKeys.staticAccountKeys[0];\n    if (!feePayer) throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_FEE_PAYER);\n\n    const instructions = transaction.message.compiledInstructions.map(instruction =>\n        convertInstruction(transaction.message, accountKeys, instruction),\n    );\n\n    // Check first instruction is durable nonce + extract params\n    if (instructions.length === 0) {\n        throw new SolanaError(SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_NO_INSTRUCTIONS);\n    }\n\n    if (!isAdvanceNonceAccountInstruction(instructions[0])) {\n        throw new SolanaError(SOLANA_ERROR__TRANSACTION_INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_NOT_ADVANCE_NONCE);\n    }\n\n    // We know these accounts are defined because we checked `isAdvanceNonceAccountInstruction`\n    const nonceAccountAddress = instructions[0].accounts![0].address;\n    assertIsAddress(nonceAccountAddress);\n\n    const nonceAuthorityAddress = instructions[0].accounts![2].address;\n    assertIsAddress(nonceAuthorityAddress);\n\n    const durableNonceLifetime = {\n        nonce: transaction.message.recentBlockhash as Nonce,\n        nonceAccountAddress,\n        nonceAuthorityAddress,\n    };\n\n    const signatures = convertSignatures(transaction, accountKeys.staticAccountKeys);\n\n    return pipe(\n        createTransaction({ version: transaction.version }),\n        tx => setTransactionFeePayer(feePayer.toBase58() as Address, tx),\n        tx => setTransactionLifetimeUsingDurableNonce(durableNonceLifetime, tx),\n        tx =>\n            instructions.slice(1).reduce((acc, instruction) => {\n                return appendTransactionInstruction(instruction, acc);\n            }, tx),\n        tx => (transaction.signatures.length ? { ...tx, signatures } : tx),\n    );\n}\n"]}