@solana/transactions 2.0.0-experimental.c5061ae → 2.0.0-experimental.c7ef49c

package/dist/index.development.js

@@ -9,7 +9,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return value;
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
   var mergeBytes = (bytesArr) => {
     const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);
     const result = new Uint8Array(totalLength);
@@ -29,7 +29,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   };
   var fixBytes = (bytes2, length) => padBytes(bytes2.slice(0, length), length);
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
   var DeserializingEmptyBufferError = class extends Error {
     constructor(serializer) {
       super(`Serializer [${serializer}] cannot deserialize empty buffers.`);
@@ -50,7 +50,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
   function fixSerializer(serializer, fixedBytes, description) {
     return {
       description: description ?? `fixed(${fixedBytes}, ${serializer.description})`,
@@ -71,7 +71,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/mapSerializer.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.9/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/mapSerializer.mjs
   function mapSerializer(serializer, unmap, map) {
     return {
       description: serializer.description,
@@ -85,7 +85,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
   var InvalidBaseStringError = class extends Error {
     constructor(value, base, cause) {
       const message = `Expected a string of base ${base}, got [${value}].`;
@@ -95,7 +95,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
   var baseX = (alphabet) => {
     const base = alphabet.length;
     const baseBigInt = BigInt(base);
@@ -149,16 +149,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
   var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
   var removeNullCharacters = (value) => (
     // eslint-disable-next-line no-control-regex
     value.replace(/\u0000/g, "")
   );
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
   var utf8 = {
     description: "utf8",
     fixedSize: null,
@@ -172,14 +172,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
   var Endian;
   (function(Endian2) {
     Endian2["Little"] = "le";
     Endian2["Big"] = "be";
   })(Endian || (Endian = {}));
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
   var NumberOutOfRangeError = class extends RangeError {
     constructor(serializer, min, max, actual) {
       super(`Serializer [${serializer}] expected number to be between ${min} and ${max}, got ${actual}.`);
@@ -187,7 +187,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
   function numberFactory(input) {
     let littleEndian;
     let defaultDescription = input.name;
@@ -231,7 +231,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u8.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u8.mjs
   var u8 = (options = {}) => numberFactory({
     name: "u8",
     size: 1,
@@ -241,7 +241,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     options
   });
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
   var u32 = (options = {}) => numberFactory({
     name: "u32",
     size: 4,
@@ -251,7 +251,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     options
   });
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/shortU16.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/shortU16.mjs
   var shortU16 = (options = {}) => ({
     description: options.description ?? "shortU16",
     fixedSize: null,
@@ -288,7 +288,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   });
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/errors.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/errors.mjs
   var InvalidNumberOfItemsError = class extends Error {
     constructor(serializer, expected, actual) {
       super(`Expected [${serializer}] to have ${expected} items, got ${actual}.`);
@@ -308,12 +308,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/sumSerializerSizes.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/sumSerializerSizes.mjs
   function sumSerializerSizes(sizes) {
     return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
   function getResolvedSize(size, childrenSizes, bytes2, offset) {
     if (typeof size === "number") {
       return [size, offset];
@@ -349,7 +349,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return typeof size === "object" ? size.serialize(realSize) : new Uint8Array();
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
   function array(item, options = {}) {
     const size = options.size ?? u32();
     if (size === "remainder" && item.fixedSize === null) {
@@ -382,7 +382,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/bytes.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/bytes.mjs
   function bytes(options = {}) {
     const size = options.size ?? "variable";
     const description = options.description ?? `bytes(${getSizeDescription(size)})`;
@@ -429,7 +429,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
   function string(options = {}) {
     const size = options.size ?? u32();
     const encoding = options.encoding ?? utf8;
@@ -470,7 +470,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/struct.mjs
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.9/node_modules/@metaplex-foundation/umi-serializers/dist/esm/struct.mjs
   function struct(fields, options = {}) {
     const fieldDescriptions = fields.map(([name, serializer]) => `${String(name)}: ${serializer.description}`).join(", ");
     return {
@@ -522,9 +522,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       if (numBytes !== 32) {
         throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
       }
-    } catch (e) {
+    } catch (e2) {
       throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-        cause: e
+        cause: e2
       });
     }
   }
@@ -583,6 +583,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
       throw new Error("Transaction is not a durable nonce transaction");
     }
   }
+  function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
+    return {
+      accounts: [
+        { address: nonceAccountAddress, role: AccountRole.WRITABLE },
+        {
+          address: RECENT_BLOCKHASHES_SYSVAR_ADDRESS,
+          role: AccountRole.READONLY
+        },
+        { address: nonceAuthorityAddress, role: AccountRole.READONLY_SIGNER }
+      ],
+      data: new Uint8Array([4, 0, 0, 0]),
+      programAddress: SYSTEM_PROGRAM_ADDRESS
+    };
+  }
   function isAdvanceNonceAccountInstruction(instruction) {
     return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && // Test for `AdvanceNonceAccount` instruction data
     instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && // Test for exactly 3 accounts
@@ -597,6 +611,28 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function isDurableNonceTransaction(transaction) {
     return "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.nonce === "string" && transaction.instructions[0] != null && isAdvanceNonceAccountInstruction(transaction.instructions[0]);
   }
+  function setTransactionLifetimeUsingDurableNonce({
+    nonce,
+    nonceAccountAddress,
+    nonceAuthorityAddress
+  }, transaction) {
+    const isAlreadyDurableNonceTransaction = isDurableNonceTransaction(transaction);
+    if (isAlreadyDurableNonceTransaction && transaction.lifetimeConstraint.nonce === nonce && transaction.instructions[0].accounts[0].address === nonceAccountAddress && transaction.instructions[0].accounts[2].address === nonceAuthorityAddress) {
+      return transaction;
+    }
+    const out = {
+      ...getUnsignedTransaction(transaction),
+      instructions: [
+        createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+        ...isAlreadyDurableNonceTransaction ? transaction.instructions.slice(1) : transaction.instructions
+      ],
+      lifetimeConstraint: {
+        nonce
+      }
+    };
+    Object.freeze(out);
+    return out;
+  }
 
   // src/fee-payer.ts
   function setTransactionFeePayer(feePayer, transaction) {
@@ -628,23 +664,339 @@ this.globalThis.solanaWeb3 = (function (exports) {
     Object.freeze(out);
     return out;
   }
-  function getBase58EncodedAddressCodec(config) {
-    return string({
-      description: config?.description ?? ("A 32-byte account address" ),
-      encoding: base58,
-      size: 32
+
+  // ../codecs-core/dist/index.browser.js
+  function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes2, offset = 0) {
+    if (bytes2.length - offset <= 0) {
+      throw new Error(`Codec [${codecDescription}] cannot decode empty byte arrays.`);
+    }
+  }
+  function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes2, offset = 0) {
+    const bytesLength = bytes2.length - offset;
+    if (bytesLength < expected) {
+      throw new Error(`Codec [${codecDescription}] expected ${expected} bytes, got ${bytesLength}.`);
+    }
+  }
+  var mergeBytes2 = (byteArrays) => {
+    const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);
+    if (nonEmptyByteArrays.length === 0) {
+      return byteArrays.length ? byteArrays[0] : new Uint8Array();
+    }
+    if (nonEmptyByteArrays.length === 1) {
+      return nonEmptyByteArrays[0];
+    }
+    const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    nonEmptyByteArrays.forEach((arr) => {
+      result.set(arr, offset);
+      offset += arr.length;
     });
+    return result;
+  };
+  var padBytes2 = (bytes2, length) => {
+    if (bytes2.length >= length)
+      return bytes2;
+    const paddedBytes = new Uint8Array(length).fill(0);
+    paddedBytes.set(bytes2);
+    return paddedBytes;
+  };
+  var fixBytes2 = (bytes2, length) => padBytes2(bytes2.length <= length ? bytes2 : bytes2.slice(0, length), length);
+  function combineCodec(encoder, decoder, description) {
+    if (encoder.fixedSize !== decoder.fixedSize) {
+      throw new Error(
+        `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`
+      );
+    }
+    if (encoder.maxSize !== decoder.maxSize) {
+      throw new Error(
+        `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`
+      );
+    }
+    if (description === void 0 && encoder.description !== decoder.description) {
+      throw new Error(
+        `Encoder and decoder must have the same description, got [${encoder.description}] and [${decoder.description}]. Pass a custom description as a third argument if you want to override the description and bypass this error.`
+      );
+    }
+    return {
+      decode: decoder.decode,
+      description: description ?? encoder.description,
+      encode: encoder.encode,
+      fixedSize: encoder.fixedSize,
+      maxSize: encoder.maxSize
+    };
   }
-  function getBase58EncodedAddressComparator() {
-    return new Intl.Collator("en", {
-      caseFirst: "lower",
-      ignorePunctuation: false,
-      localeMatcher: "best fit",
-      numeric: false,
-      sensitivity: "variant",
-      usage: "sort"
-    }).compare;
+  function fixCodecHelper(data, fixedBytes, description) {
+    return {
+      description: description ?? `fixed(${fixedBytes}, ${data.description})`,
+      fixedSize: fixedBytes,
+      maxSize: fixedBytes
+    };
+  }
+  function fixEncoder(encoder, fixedBytes, description) {
+    return {
+      ...fixCodecHelper(encoder, fixedBytes, description),
+      encode: (value) => fixBytes2(encoder.encode(value), fixedBytes)
+    };
+  }
+  function fixDecoder(decoder, fixedBytes, description) {
+    return {
+      ...fixCodecHelper(decoder, fixedBytes, description),
+      decode: (bytes2, offset = 0) => {
+        assertByteArrayHasEnoughBytesForCodec("fixCodec", fixedBytes, bytes2, offset);
+        if (offset > 0 || bytes2.length > fixedBytes) {
+          bytes2 = bytes2.slice(offset, offset + fixedBytes);
+        }
+        if (decoder.fixedSize !== null) {
+          bytes2 = fixBytes2(bytes2, decoder.fixedSize);
+        }
+        const [value] = decoder.decode(bytes2, 0);
+        return [value, offset + fixedBytes];
+      }
+    };
+  }
+  function mapEncoder(encoder, unmap) {
+    return {
+      description: encoder.description,
+      encode: (value) => encoder.encode(unmap(value)),
+      fixedSize: encoder.fixedSize,
+      maxSize: encoder.maxSize
+    };
   }
+
+  // ../codecs-numbers/dist/index.browser.js
+  function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
+    if (value < min || value > max) {
+      throw new Error(
+        `Codec [${codecDescription}] expected number to be in the range [${min}, ${max}], got ${value}.`
+      );
+    }
+  }
+  function sharedNumberFactory(input) {
+    let littleEndian;
+    let defaultDescription = input.name;
+    if (input.size > 1) {
+      littleEndian = !("endian" in input.options) || input.options.endian === 0;
+      defaultDescription += littleEndian ? "(le)" : "(be)";
+    }
+    return {
+      description: input.options.description ?? defaultDescription,
+      fixedSize: input.size,
+      littleEndian,
+      maxSize: input.size
+    };
+  }
+  function numberEncoderFactory(input) {
+    const codecData = sharedNumberFactory(input);
+    return {
+      description: codecData.description,
+      encode(value) {
+        if (input.range) {
+          assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
+        }
+        const arrayBuffer = new ArrayBuffer(input.size);
+        input.set(new DataView(arrayBuffer), value, codecData.littleEndian);
+        return new Uint8Array(arrayBuffer);
+      },
+      fixedSize: codecData.fixedSize,
+      maxSize: codecData.maxSize
+    };
+  }
+  function numberDecoderFactory(input) {
+    const codecData = sharedNumberFactory(input);
+    return {
+      decode(bytes2, offset = 0) {
+        assertByteArrayIsNotEmptyForCodec(codecData.description, bytes2, offset);
+        assertByteArrayHasEnoughBytesForCodec(codecData.description, input.size, bytes2, offset);
+        const view = new DataView(toArrayBuffer2(bytes2, offset, input.size));
+        return [input.get(view, codecData.littleEndian), offset + input.size];
+      },
+      description: codecData.description,
+      fixedSize: codecData.fixedSize,
+      maxSize: codecData.maxSize
+    };
+  }
+  function toArrayBuffer2(bytes2, offset, length) {
+    const bytesOffset = bytes2.byteOffset + (offset ?? 0);
+    const bytesLength = length ?? bytes2.byteLength;
+    return bytes2.buffer.slice(bytesOffset, bytesOffset + bytesLength);
+  }
+  var getU32Encoder = (options = {}) => numberEncoderFactory({
+    name: "u32",
+    options,
+    range: [0, Number("0xffffffff")],
+    set: (view, value, le) => view.setUint32(0, value, le),
+    size: 4
+  });
+  var getU32Decoder = (options = {}) => numberDecoderFactory({
+    get: (view, le) => view.getUint32(0, le),
+    name: "u32",
+    options,
+    size: 4
+  });
+  var getU8Encoder = (options = {}) => numberEncoderFactory({
+    name: "u8",
+    options,
+    range: [0, Number("0xff")],
+    set: (view, value) => view.setUint8(0, value),
+    size: 1
+  });
+  var getU8Decoder = (options = {}) => numberDecoderFactory({
+    get: (view) => view.getUint8(0),
+    name: "u8",
+    options,
+    size: 1
+  });
+  var getU8Codec = (options = {}) => combineCodec(getU8Encoder(options), getU8Decoder(options));
+
+  // ../codecs-strings/dist/index.browser.js
+  function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+    if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
+      throw new Error(`Expected a string of base ${alphabet4.length}, got [${givenValue}].`);
+    }
+  }
+  var getBaseXEncoder = (alphabet4) => {
+    const base = alphabet4.length;
+    const baseBigInt = BigInt(base);
+    return {
+      description: `base${base}`,
+      encode(value) {
+        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;
+        }
+        const tailBytes = [];
+        while (base10Number > 0n) {
+          tailBytes.unshift(Number(base10Number % 256n));
+          base10Number /= 256n;
+        }
+        return Uint8Array.from(leadingZeroes.concat(tailBytes));
+      },
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  var getBaseXDecoder = (alphabet4) => {
+    const base = alphabet4.length;
+    const baseBigInt = BigInt(base);
+    return {
+      decode(rawBytes, offset = 0) {
+        const bytes2 = offset === 0 ? rawBytes : rawBytes.slice(offset);
+        if (bytes2.length === 0)
+          return ["", 0];
+        let trailIndex = bytes2.findIndex((n) => n !== 0);
+        trailIndex = trailIndex === -1 ? bytes2.length : trailIndex;
+        const leadingZeroes = alphabet4[0].repeat(trailIndex);
+        if (trailIndex === bytes2.length)
+          return [leadingZeroes, rawBytes.length];
+        let base10Number = bytes2.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
+        const tailChars = [];
+        while (base10Number > 0n) {
+          tailChars.unshift(alphabet4[Number(base10Number % baseBigInt)]);
+          base10Number /= baseBigInt;
+        }
+        return [leadingZeroes + tailChars.join(""), rawBytes.length];
+      },
+      description: `base${base}`,
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+  var getBase58Decoder = () => getBaseXDecoder(alphabet2);
+  var removeNullCharacters2 = (value) => (
+    // eslint-disable-next-line no-control-regex
+    value.replace(/\u0000/g, "")
+  );
+  var e = globalThis.TextDecoder;
+  var o = globalThis.TextEncoder;
+  var getUtf8Encoder = () => {
+    let textEncoder;
+    return {
+      description: "utf8",
+      encode: (value) => new Uint8Array((textEncoder || (textEncoder = new o())).encode(value)),
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  var getUtf8Decoder = () => {
+    let textDecoder;
+    return {
+      decode(bytes2, offset = 0) {
+        const value = (textDecoder || (textDecoder = new e())).decode(bytes2.slice(offset));
+        return [removeNullCharacters2(value), bytes2.length];
+      },
+      description: "utf8",
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  var getStringEncoder = (options = {}) => {
+    const size = options.size ?? getU32Encoder();
+    const encoding = options.encoding ?? getUtf8Encoder();
+    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription2(size)})`;
+    if (size === "variable") {
+      return { ...encoding, description };
+    }
+    if (typeof size === "number") {
+      return fixEncoder(encoding, size, description);
+    }
+    return {
+      description,
+      encode: (value) => {
+        const contentBytes = encoding.encode(value);
+        const lengthBytes = size.encode(contentBytes.length);
+        return mergeBytes2([lengthBytes, contentBytes]);
+      },
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  var getStringDecoder = (options = {}) => {
+    const size = options.size ?? getU32Decoder();
+    const encoding = options.encoding ?? getUtf8Decoder();
+    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription2(size)})`;
+    if (size === "variable") {
+      return { ...encoding, description };
+    }
+    if (typeof size === "number") {
+      return fixDecoder(encoding, size, description);
+    }
+    return {
+      decode: (bytes2, offset = 0) => {
+        assertByteArrayIsNotEmptyForCodec("string", bytes2, offset);
+        const [lengthBigInt, lengthOffset] = size.decode(bytes2, offset);
+        const length = Number(lengthBigInt);
+        offset = lengthOffset;
+        const contentBytes = bytes2.slice(offset, offset + length);
+        assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
+        const [value, contentOffset] = encoding.decode(contentBytes);
+        offset += contentOffset;
+        return [value, offset];
+      },
+      description,
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  function getSizeDescription2(size) {
+    return typeof size === "object" ? size.description : `${size}`;
+  }
+
+  // ../assertions/dist/index.browser.js
   function assertIsSecureContext() {
     if (!globalThis.isSecureContext) {
       throw new Error(
@@ -664,24 +1016,88 @@ this.globalThis.solanaWeb3 = (function (exports) {
       throw new Error("No signing implementation could be found");
     }
   }
-  async function getBase58EncodedAddressFromPublicKey(publicKey) {
+
+  // ../addresses/dist/index.browser.js
+  var memoizedBase58Encoder;
+  var memoizedBase58Decoder;
+  function getMemoizedBase58Encoder() {
+    if (!memoizedBase58Encoder)
+      memoizedBase58Encoder = getBase58Encoder();
+    return memoizedBase58Encoder;
+  }
+  function getMemoizedBase58Decoder() {
+    if (!memoizedBase58Decoder)
+      memoizedBase58Decoder = getBase58Decoder();
+    return memoizedBase58Decoder;
+  }
+  function assertIsAddress(putativeBase58EncodedAddress) {
+    try {
+      if (
+        // Lowest address (32 bytes of zeroes)
+        putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
+        putativeBase58EncodedAddress.length > 44
+      ) {
+        throw new Error("Expected input string to decode to a byte array of length 32.");
+      }
+      const base58Encoder = getMemoizedBase58Encoder();
+      const bytes2 = base58Encoder.encode(putativeBase58EncodedAddress);
+      const numBytes = bytes2.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(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
+        cause: e2
+      });
+    }
+  }
+  function address(putativeBase58EncodedAddress) {
+    assertIsAddress(putativeBase58EncodedAddress);
+    return putativeBase58EncodedAddress;
+  }
+  function getAddressEncoder(config) {
+    return mapEncoder(
+      getStringEncoder({
+        description: config?.description ?? "Base58EncodedAddress",
+        encoding: getMemoizedBase58Encoder(),
+        size: 32
+      }),
+      (putativeAddress) => address(putativeAddress)
+    );
+  }
+  function getAddressDecoder(config) {
+    return getStringDecoder({
+      description: config?.description ?? "Base58EncodedAddress",
+      encoding: getMemoizedBase58Decoder(),
+      size: 32
+    });
+  }
+  function getAddressCodec(config) {
+    return combineCodec(getAddressEncoder(config), getAddressDecoder(config));
+  }
+  function getAddressComparator() {
+    return new Intl.Collator("en", {
+      caseFirst: "lower",
+      ignorePunctuation: false,
+      localeMatcher: "best fit",
+      numeric: false,
+      sensitivity: "variant",
+      usage: "sort"
+    }).compare;
+  }
+  async function getAddressFromPublicKey(publicKey) {
     await assertKeyExporterIsAvailable();
     if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") {
       throw new Error("The `CryptoKey` must be an `Ed25519` public key");
     }
     const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
-    const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes));
+    const [base58EncodedAddress] = getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
     return base58EncodedAddress;
   }
-  async function signBytes(key, data) {
-    await assertSigningCapabilityIsAvailable();
-    const signedData = await crypto.subtle.sign("Ed25519", key, data);
-    return new Uint8Array(signedData);
-  }
 
   // src/accounts.ts
-  function upsert(addressMap, address, update) {
-    addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
+  function upsert(addressMap, address2, update) {
+    addressMap[address2] = update(addressMap[address2] ?? { role: AccountRole.READONLY });
   }
   var TYPE = Symbol("AddressMapTypeProperty");
   function getAddressMapFromInstructions(feePayer, instructions) {
@@ -732,7 +1148,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
                   const shouldReplaceEntry = (
                     // Consider using the new LOOKUP_TABLE if its address is different...
                     entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
-                    (addressComparator || (addressComparator = getBase58EncodedAddressComparator()))(
+                    (addressComparator || (addressComparator = getAddressComparator()))(
                       accountMeta.lookupTableAddress,
                       entry.lookupTableAddress
                     ) < 0
@@ -838,14 +1254,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
       if (leftIsWritable !== isWritableRole(rightEntry.role)) {
         return leftIsWritable ? -1 : 1;
       }
-      addressComparator || (addressComparator = getBase58EncodedAddressComparator());
+      addressComparator || (addressComparator = getAddressComparator());
       if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
         return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
       } else {
         return addressComparator(leftAddress, rightAddress);
       }
-    }).map(([address, addressMeta]) => ({
-      address,
+    }).map(([address2, addressMeta]) => ({
+      address: address2,
       ...addressMeta
     }));
     return orderedAccounts;
@@ -869,7 +1285,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
         entry.readableIndices.push(account.addressIndex);
       }
     }
-    return Object.keys(index).sort(getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
+    return Object.keys(index).sort(getAddressComparator()).map((lookupTableAddress) => ({
       lookupTableAddress,
       ...index[lookupTableAddress]
     }));
@@ -914,7 +1330,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return instructions.map(({ accounts, data, programAddress }) => {
       return {
         programAddressIndex: accountIndex[programAddress],
-        ...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
+        ...accounts ? { accountIndices: accounts.map(({ address: address2 }) => accountIndex[address2]) } : null,
         ...data ? { data } : null
       };
     });
@@ -932,7 +1348,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function getCompiledStaticAccounts(orderedAccounts) {
     const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
     const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
-    return orderedStaticAccounts.map(({ address }) => address);
+    return orderedStaticAccounts.map(({ address: address2 }) => address2);
   }
 
   // src/message.ts
@@ -949,13 +1365,41 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
+  // src/compile-transaction.ts
+  function getCompiledTransaction(transaction) {
+    const compiledMessage = compileMessage(transaction);
+    let signatures;
+    if ("signatures" in transaction) {
+      signatures = [];
+      for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
+        signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
+      }
+    } else {
+      signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
+    }
+    return {
+      compiledMessage,
+      signatures
+    };
+  }
+
   // src/serializers/address-table-lookup.ts
+  function addressSerializerCompat(compat) {
+    const codec = getAddressCodec();
+    return {
+      description: compat?.description ?? codec.description,
+      deserialize: codec.decode,
+      fixedSize: codec.fixedSize,
+      maxSize: codec.maxSize,
+      serialize: codec.encode
+    };
+  }
   function getAddressTableLookupCodec() {
     return struct(
       [
         [
           "lookupTableAddress",
-          getBase58EncodedAddressCodec(
+          addressSerializerCompat(
             {
               description: "The address of the address lookup table account from which instruction addresses should be looked up"
             } 
@@ -986,38 +1430,73 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
   }
 
+  // ../codecs-data-structures/dist/index.browser.js
+  function sumCodecSizes(sizes) {
+    return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
+  }
+  function structCodecHelper(fields, description) {
+    const fieldDescriptions = fields.map(([name, codec]) => `${String(name)}: ${codec.description}`).join(", ");
+    return {
+      description: description ?? `struct(${fieldDescriptions})`,
+      fixedSize: sumCodecSizes(fields.map(([, field]) => field.fixedSize)),
+      maxSize: sumCodecSizes(fields.map(([, field]) => field.maxSize))
+    };
+  }
+  function getStructEncoder(fields, options = {}) {
+    return {
+      ...structCodecHelper(fields, options.description),
+      encode: (struct2) => {
+        const fieldBytes = fields.map(([key, codec]) => codec.encode(struct2[key]));
+        return mergeBytes2(fieldBytes);
+      }
+    };
+  }
+  function getStructDecoder(fields, options = {}) {
+    return {
+      ...structCodecHelper(fields, options.description),
+      decode: (bytes2, offset = 0) => {
+        const struct2 = {};
+        fields.forEach(([key, codec]) => {
+          const [value, newOffset] = codec.decode(bytes2, offset);
+          offset = newOffset;
+          struct2[key] = value;
+        });
+        return [struct2, offset];
+      }
+    };
+  }
+  function getStructCodec(fields, options = {}) {
+    return combineCodec(getStructEncoder(fields, options), getStructDecoder(fields, options));
+  }
+
   // src/serializers/header.ts
+  var memoizedU8Codec;
+  function getMemoizedU8Codec() {
+    if (!memoizedU8Codec)
+      memoizedU8Codec = getU8Codec();
+    return memoizedU8Codec;
+  }
+  function getMemoizedU8CodecDescription(description) {
+    const codec = getMemoizedU8Codec();
+    return {
+      ...codec,
+      description: description ?? codec.description
+    };
+  }
+  var numSignerAccountsDescription = "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction" ;
+  var numReadonlySignerAccountsDescription = "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable" ;
+  var numReadonlyNonSignerAccountsDescription = "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable" ;
+  var messageHeaderDescription = "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses" ;
   function getMessageHeaderCodec() {
-    return struct(
+    return getStructCodec(
       [
-        [
-          "numSignerAccounts",
-          u8(
-            {
-              description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
-            } 
-          )
-        ],
-        [
-          "numReadonlySignerAccounts",
-          u8(
-            {
-              description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable"
-            } 
-          )
-        ],
-        [
-          "numReadonlyNonSignerAccounts",
-          u8(
-            {
-              description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
-            } 
-          )
-        ]
+        ["numSignerAccounts", getMemoizedU8CodecDescription(numSignerAccountsDescription)],
+        ["numReadonlySignerAccounts", getMemoizedU8CodecDescription(numReadonlySignerAccountsDescription)],
+        ["numReadonlyNonSignerAccounts", getMemoizedU8CodecDescription(numReadonlyNonSignerAccountsDescription)]
       ],
       {
-        description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
-      } 
+        description: messageHeaderDescription
+      }
     );
   }
 
@@ -1034,7 +1513,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           )
         ],
         [
-          "addressIndices",
+          "accountIndices",
           array(
             u8({
               description: "The index of an account, according to the well-ordered accounts list for this transaction" 
@@ -1054,42 +1533,29 @@ this.globalThis.solanaWeb3 = (function (exports) {
         ]
       ]),
       (value) => {
-        if (value.addressIndices !== void 0 && value.data !== void 0) {
+        if (value.accountIndices !== void 0 && value.data !== void 0) {
           return value;
         }
         return {
           ...value,
-          addressIndices: value.addressIndices ?? [],
+          accountIndices: value.accountIndices ?? [],
           data: value.data ?? new Uint8Array(0)
         };
       },
       (value) => {
-        if (value.addressIndices.length && value.data.byteLength) {
+        if (value.accountIndices.length && value.data.byteLength) {
           return value;
         }
-        const { addressIndices, data, ...rest } = value;
+        const { accountIndices, data, ...rest } = value;
         return {
           ...rest,
-          ...addressIndices.length ? { addressIndices } : null,
+          ...accountIndices.length ? { accountIndices } : null,
           ...data.byteLength ? { data } : null
         };
       }
     );
   }
 
-  // src/serializers/unimplemented.ts
-  function getError(type, name) {
-    const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
-    return new Error(
-      `No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
-    );
-  }
-  function getUnimplementedDecoder(name) {
-    return () => {
-      throw getError("decoder", name);
-    };
-  }
-
   // src/serializers/transaction-version.ts
   var VERSION_FLAG_MASK = 128;
   var BASE_CONFIG = {
@@ -1097,7 +1563,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     fixedSize: null,
     maxSize: 1
   };
-  function deserialize(bytes2, offset = 0) {
+  function decode(bytes2, offset = 0) {
     const firstByte = bytes2[offset];
     if ((firstByte & VERSION_FLAG_MASK) === 0) {
       return ["legacy", offset];
@@ -1106,7 +1572,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return [version, offset + 1];
     }
   }
-  function serialize(value) {
+  function encode(value) {
     if (value === "legacy") {
       return new Uint8Array();
     }
@@ -1115,11 +1581,32 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return new Uint8Array([value | VERSION_FLAG_MASK]);
   }
-  function getTransactionVersionCodec() {
+  function getTransactionVersionDecoder() {
     return {
       ...BASE_CONFIG,
-      deserialize,
-      serialize
+      decode
+    };
+  }
+  function getTransactionVersionEncoder() {
+    return {
+      ...BASE_CONFIG,
+      encode
+    };
+  }
+  function getTransactionVersionCodec() {
+    return combineCodec(getTransactionVersionEncoder(), getTransactionVersionDecoder());
+  }
+
+  // src/serializers/unimplemented.ts
+  function getError(type, name) {
+    const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
+    return new Error(
+      `No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
+    );
+  }
+  function getUnimplementedDecoder(name) {
+    return () => {
+      throw getError("decoder", name);
     };
   }
 
@@ -1129,7 +1616,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     fixedSize: null,
     maxSize: null
   };
-  function serialize2(compiledMessage) {
+  function serialize(compiledMessage) {
     if (compiledMessage.version === "legacy") {
       return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
     } else {
@@ -1150,13 +1637,22 @@ this.globalThis.solanaWeb3 = (function (exports) {
       ).serialize(compiledMessage);
     }
   }
+  function toSerializer(codec) {
+    return {
+      description: codec.description,
+      deserialize: codec.decode,
+      fixedSize: codec.fixedSize,
+      maxSize: codec.maxSize,
+      serialize: codec.encode
+    };
+  }
   function getPreludeStructSerializerTuple() {
     return [
-      ["version", getTransactionVersionCodec()],
-      ["header", getMessageHeaderCodec()],
+      ["version", toSerializer(getTransactionVersionCodec())],
+      ["header", toSerializer(getMessageHeaderCodec())],
       [
         "staticAccounts",
-        array(getBase58EncodedAddressCodec(), {
+        array(toSerializer(getAddressCodec()), {
           description: "A compact-array of static account addresses belonging to this transaction" ,
           size: shortU16()
         })
@@ -1188,49 +1684,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return {
       ...BASE_CONFIG2,
       deserialize: getUnimplementedDecoder("CompiledMessage"),
-      serialize: serialize2
-    };
-  }
-
-  // src/signatures.ts
-  async function getCompiledMessageSignature(message, secretKey) {
-    const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
-    const signature = await signBytes(secretKey, wireMessageBytes);
-    return signature;
-  }
-  async function signTransaction(keyPair, transaction) {
-    const compiledMessage = compileMessage(transaction);
-    const [signerPublicKey, signature] = await Promise.all([
-      getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
-      getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
-    ]);
-    const nextSignatures = {
-      ..."signatures" in transaction ? transaction.signatures : null,
-      ...{ [signerPublicKey]: signature }
-    };
-    const out = {
-      ...transaction,
-      signatures: nextSignatures
-    };
-    Object.freeze(out);
-    return out;
-  }
-
-  // src/compile-transaction.ts
-  function getCompiledTransaction(transaction) {
-    const compiledMessage = compileMessage(transaction);
-    let signatures;
-    if ("signatures" in transaction) {
-      signatures = [];
-      for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
-        signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
-      }
-    } else {
-      signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
-    }
-    return {
-      compiledMessage,
-      signatures
+      serialize
     };
   }
 
@@ -1240,7 +1694,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     fixedSize: null,
     maxSize: null
   };
-  function serialize3(transaction) {
+  function serialize2(transaction) {
     const compiledTransaction = getCompiledTransaction(transaction);
     return struct([
       [
@@ -1257,10 +1711,93 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return {
       ...BASE_CONFIG3,
       deserialize: getUnimplementedDecoder("CompiledMessage"),
-      serialize: serialize3
+      serialize: serialize2
     };
   }
 
+  // ../keys/dist/index.browser.js
+  async function signBytes(key, data) {
+    await assertSigningCapabilityIsAvailable();
+    const signedData = await crypto.subtle.sign("Ed25519", key, data);
+    return new Uint8Array(signedData);
+  }
+
+  // src/signatures.ts
+  function assertIsTransactionSignature(putativeTransactionSignature) {
+    try {
+      if (
+        // Lowest value (64 bytes of zeroes)
+        putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
+        putativeTransactionSignature.length > 88
+      ) {
+        throw new Error("Expected input string to decode to a byte array of length 64.");
+      }
+      const bytes2 = base58.serialize(putativeTransactionSignature);
+      const numBytes = bytes2.byteLength;
+      if (numBytes !== 64) {
+        throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+      }
+    } catch (e2) {
+      throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
+        cause: e2
+      });
+    }
+  }
+  function isTransactionSignature(putativeTransactionSignature) {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeTransactionSignature.length > 88
+    ) {
+      return false;
+    }
+    const bytes2 = base58.serialize(putativeTransactionSignature);
+    const numBytes = bytes2.byteLength;
+    if (numBytes !== 64) {
+      return false;
+    }
+    return true;
+  }
+  async function getCompiledMessageSignature(message, secretKey) {
+    const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
+    const signature = await signBytes(secretKey, wireMessageBytes);
+    return signature;
+  }
+  function getSignatureFromTransaction(transaction) {
+    const signature = transaction.signatures[transaction.feePayer];
+    if (!signature) {
+      throw new Error(
+        "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
+      );
+    }
+    return signature;
+  }
+  async function signTransaction(keyPairs, transaction) {
+    const compiledMessage = compileMessage(transaction);
+    const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
+    const publicKeySignaturePairs = await Promise.all(
+      keyPairs.map(
+        (keyPair) => Promise.all([
+          getAddressFromPublicKey(keyPair.publicKey),
+          getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
+        ])
+      )
+    );
+    for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+      nextSignatures[signerPublicKey] = signature;
+    }
+    const out = {
+      ...transaction,
+      signatures: nextSignatures
+    };
+    Object.freeze(out);
+    return out;
+  }
+  function transactionSignature(putativeTransactionSignature) {
+    assertIsTransactionSignature(putativeTransactionSignature);
+    return putativeTransactionSignature;
+  }
+
   // src/wire-transaction.ts
   function getBase64EncodedWireTransaction(transaction) {
     const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
@@ -1272,12 +1809,18 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.appendTransactionInstruction = appendTransactionInstruction;
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
+  exports.assertIsTransactionSignature = assertIsTransactionSignature;
   exports.createTransaction = createTransaction;
   exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
+  exports.getSignatureFromTransaction = getSignatureFromTransaction;
+  exports.getTransactionEncoder = getTransactionEncoder;
+  exports.isTransactionSignature = isTransactionSignature;
   exports.prependTransactionInstruction = prependTransactionInstruction;
   exports.setTransactionFeePayer = setTransactionFeePayer;
   exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockhash;
+  exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;
   exports.signTransaction = signTransaction;
+  exports.transactionSignature = transactionSignature;
 
   return exports;