@solana/kit 5.0.1-canary-20251119203851 → 5.1.0-canary-20251204140906

package/dist/index.development.js

@@ -142,6 +142,24 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS = 5508009;
   var SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING = 5508010;
   var SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED = 5508011;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED = 5607e3;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE = 5607001;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE = 5607002;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH = 5607003;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH = 5607004;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO = 5607005;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED = 5607006;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH = 5607007;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH = 5607008;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY = 5607009;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO = 5607010;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING = 5607011;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH = 5607012;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE = 5607013;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION = 5607014;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED = 5607015;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE = 5607016;
+  var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE = 5607017;
   var SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES = 5663e3;
   var SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE = 5663001;
   var SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME = 5663002;
@@ -396,6 +414,24 @@ this.globalThis.solanaWeb3 = (function (exports) {
     [SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR]: "$message",
     [SOLANA_ERROR__MALFORMED_NUMBER_STRING]: "`$value` cannot be parsed as a `Number`",
     [SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND]: "No nonce account could be found at address `$nonceAccountAddress`",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH]: "Expected base58 encoded application domain to decode to a byte array of length 32. Actual length: $actualLength.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE]: "Attempted to sign an offchain message with an address that is not a signer for it",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded application domain string of length in the range [32, 44]. Actual length: $actualLength.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH]: "The signer addresses in this offchain message envelope do not match the list of required signers in the message preamble. These unexpected signers were present in the envelope: `[$unexpectedSigners]`. These required signers were missing from the envelope `[$missingSigners]`.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED]: "The message body provided has a byte-length of $actualBytes. The maximum allowable byte-length is $maxBytes",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH]: "Expected message format $expectedMessageFormat, got $actualMessageFormat",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH]: "The message length specified in the message preamble is $specifiedLength bytes. The actual length of the message is $actualLength bytes.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY]: "Offchain message content must be non-empty",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO]: "Offchain message must specify the address of at least one required signer",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO]: "Offchain message envelope must reserve space for at least one signature",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH]: "The offchain message preamble specifies $numRequiredSignatures required signature(s), got $signaturesLength.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED]: "The signatories of this offchain message must be listed in lexicographical order",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE]: "An address must be listed no more than once among the signatories of an offchain message",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING]: "Offchain message is missing signatures for addresses: $addresses.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE]: "Offchain message signature verification failed. Signature mismatch for required signatories [$signatoriesWithInvalidSignatures]. Missing signatures for signatories [$signatoriesWithMissingSignatures]",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE]: "The message body provided contains characters whose codes fall outside the allowed range. In order to ensure clear-signing compatiblity with hardware wallets, the message may only contain line feeds and characters in the range [\\x20-\\x7e].",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION]: "Expected offchain message version $expectedVersion. Got $actualVersion.",
+    [SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED]: "This version of Kit does not support decoding offchain messages with version $unsupportedVersion. The current max supported version is 0.",
     [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN]: "The notification name must end in 'Notifications' and the API must supply a subscription plan creator function for the notification '$notificationName'.",
     [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED]: "WebSocket was closed before payload could be added to the send buffer",
     [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED]: "WebSocket connection closed",
@@ -883,8 +919,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
   function containsBytes(data, bytes, offset) {
     const slice = offset === 0 && data.length === bytes.length ? data : data.slice(offset, offset + bytes.length);
-    if (slice.length !== bytes.length) return false;
-    return bytes.every((b, i) => b === slice[i]);
+    return bytesEqual(slice, bytes);
+  }
+  function bytesEqual(bytes1, bytes2) {
+    return bytes1.length === bytes2.length && bytes1.every((value, index) => value === bytes2[index]);
   }
   function getEncodedSize(value, encoder) {
     return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
@@ -958,7 +996,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
   function addEncoderSentinel(encoder, sentinel) {
-    const write = (value, bytes, offset) => {
+    const write = ((value, bytes, offset) => {
       const encoderBytes = encoder.encode(value);
       if (findSentinelIndex(encoderBytes, sentinel) >= 0) {
         throw new SolanaError(SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL, {
@@ -973,7 +1011,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       bytes.set(sentinel, offset);
       offset += sentinel.length;
       return offset;
-    };
+    });
     if (isFixedSize(encoder)) {
       return createEncoder({ ...encoder, fixedSize: encoder.fixedSize + sentinel.length, write });
     }
@@ -985,7 +1023,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
   function addDecoderSentinel(decoder, sentinel) {
-    const read = (bytes, offset) => {
+    const read = ((bytes, offset) => {
       const candidateBytes = offset === 0 ? bytes : bytes.slice(offset);
       const sentinelIndex = findSentinelIndex(candidateBytes, sentinel);
       if (sentinelIndex === -1) {
@@ -998,7 +1036,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
       const preSentinelBytes = candidateBytes.slice(0, sentinelIndex);
       return [decoder.decode(preSentinelBytes), offset + preSentinelBytes.length + sentinel.length];
-    };
+    });
     if (isFixedSize(decoder)) {
       return createDecoder({ ...decoder, fixedSize: decoder.fixedSize + sentinel.length, read });
     }
@@ -1048,12 +1086,12 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function addEncoderSizePrefix(encoder, prefix) {
     var _a, _b;
-    const write = (value, bytes, offset) => {
+    const write = ((value, bytes, offset) => {
       const encoderBytes = encoder.encode(value);
       offset = prefix.write(encoderBytes.length, bytes, offset);
       bytes.set(encoderBytes, offset);
       return offset + encoderBytes.length;
-    };
+    });
     if (isFixedSize(prefix) && isFixedSize(encoder)) {
       return createEncoder({ ...encoder, fixedSize: prefix.fixedSize + encoder.fixedSize, write });
     }
@@ -1072,7 +1110,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function addDecoderSizePrefix(decoder, prefix) {
     var _a, _b;
-    const read = (bytes, offset) => {
+    const read = ((bytes, offset) => {
       const [bigintSize, decoderOffset] = prefix.read(bytes, offset);
       const size = Number(bigintSize);
       offset = decoderOffset;
@@ -1081,7 +1119,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
       assertByteArrayHasEnoughBytesForCodec("addDecoderSizePrefix", size, bytes);
       return [decoder.decode(bytes), offset + size];
-    };
+    });
     if (isFixedSize(prefix) && isFixedSize(decoder)) {
       return createDecoder({ ...decoder, fixedSize: prefix.fixedSize + decoder.fixedSize, read });
     }
@@ -1994,7 +2032,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       });
     }
     const programAddressBytes = encode(programAddress);
-    if (programAddressBytes.length >= PDA_MARKER_BYTES.length && programAddressBytes.slice(-PDA_MARKER_BYTES.length).every((byte, index) => byte === PDA_MARKER_BYTES[index])) {
+    if (programAddressBytes.length >= PDA_MARKER_BYTES.length && bytesEqual(programAddressBytes.slice(-PDA_MARKER_BYTES.length), new Uint8Array(PDA_MARKER_BYTES))) {
       throw new SolanaError(SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER);
     }
     const addressBytesBuffer = await crypto.subtle.digest(
@@ -3132,10 +3170,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var IS_SIGNER_BITMASK = 2;
   var IS_WRITABLE_BITMASK = 1;
   function downgradeRoleToNonSigner(role) {
-    return role & -3;
+    return role & ~IS_SIGNER_BITMASK;
   }
   function downgradeRoleToReadonly(role) {
-    return role & -2;
+    return role & ~IS_WRITABLE_BITMASK;
   }
   function isSignerRole(role) {
     return role >= 2;
@@ -4589,9 +4627,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const transactionSignature = base58Decoder.decode(signatureBytes2);
     return transactionSignature;
   }
-  function uint8ArraysEqual(arr1, arr2) {
-    return arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
-  }
   async function partiallySignTransaction(keyPairs, transaction) {
     let newSignatures;
     let unexpectedSigners;
@@ -4608,7 +4643,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           return;
         }
         const newSignature = await signBytes(keyPair.privateKey, transaction.messageBytes);
-        if (existingSignature !== null && uint8ArraysEqual(newSignature, existingSignature)) {
+        if (existingSignature !== null && bytesEqual(newSignature, existingSignature)) {
           return;
         }
         newSignatures || (newSignatures = {});
@@ -4901,7 +4936,19 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return Object.freeze({
       kind: "single",
       message: transactionMessage,
-      status: Object.freeze({ context: context != null ? context : {}, kind: "successful", transaction })
+      status: Object.freeze({
+        context: context != null ? context : {},
+        kind: "successful",
+        signature: getSignatureFromTransaction(transaction),
+        transaction
+      })
+    });
+  }
+  function successfulSingleTransactionPlanResultFromSignature(transactionMessage, signature2, context) {
+    return Object.freeze({
+      kind: "single",
+      message: transactionMessage,
+      status: Object.freeze({ context: context != null ? context : {}, kind: "successful", signature: signature2 })
     });
   }
   function failedSingleTransactionPlanResult(transactionMessage, error) {
@@ -4918,6 +4965,48 @@ this.globalThis.solanaWeb3 = (function (exports) {
       status: Object.freeze({ kind: "canceled" })
     });
   }
+  function flattenTransactionPlanResult(result) {
+    const transactionPlanResults = [];
+    function traverse3(result2) {
+      if (result2.kind === "single") {
+        transactionPlanResults.push(result2);
+      } else {
+        for (const subResult of result2.plans) {
+          traverse3(subResult);
+        }
+      }
+    }
+    traverse3(result);
+    return transactionPlanResults;
+  }
+  function summarizeTransactionPlanResult(result) {
+    const successfulTransactions = [];
+    const failedTransactions = [];
+    const canceledTransactions = [];
+    const flattenedResults = flattenTransactionPlanResult(result);
+    for (const singleResult of flattenedResults) {
+      switch (singleResult.status.kind) {
+        case "successful": {
+          successfulTransactions.push(singleResult);
+          break;
+        }
+        case "failed": {
+          failedTransactions.push(singleResult);
+          break;
+        }
+        case "canceled": {
+          canceledTransactions.push(singleResult);
+          break;
+        }
+      }
+    }
+    return Object.freeze({
+      canceledTransactions,
+      failedTransactions,
+      successful: failedTransactions.length === 0 && canceledTransactions.length === 0,
+      successfulTransactions
+    });
+  }
   function createTransactionPlanExecutor(config) {
     return async (plan, { abortSignal } = {}) => {
       var _a, _b;
@@ -4980,7 +5069,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
         context.executeTransactionMessage(transactionPlan.message, { abortSignal: context.abortSignal }),
         context.abortSignal
       );
-      return successfulSingleTransactionPlanResult(transactionPlan.message, result.transaction, result.context);
+      if ("transaction" in result) {
+        return successfulSingleTransactionPlanResult(transactionPlan.message, result.transaction, result.context);
+      } else {
+        return successfulSingleTransactionPlanResultFromSignature(
+          transactionPlan.message,
+          result.signature,
+          result.context
+        );
+      }
     } catch (error) {
       context.canceled = true;
       return failedSingleTransactionPlanResult(transactionPlan.message, error);
@@ -5024,7 +5121,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       const plan = await traverse2(instructionPlan, {
         abortSignal,
         createTransactionMessage: config.createTransactionMessage,
-        onTransactionMessageUpdated: (_a = config.onTransactionMessageUpdated) != null ? _a : (msg) => msg,
+        onTransactionMessageUpdated: (_a = config.onTransactionMessageUpdated) != null ? _a : ((msg) => msg),
         parent: null,
         parentCandidates: []
       });
@@ -5256,6 +5353,764 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   }
 
+  // ../offchain-messages/dist/index.browser.mjs
+  function isOffchainMessageApplicationDomain(putativeApplicationDomain) {
+    return isAddress(putativeApplicationDomain);
+  }
+  function assertIsOffchainMessageApplicationDomain(putativeApplicationDomain) {
+    try {
+      assertIsAddress(putativeApplicationDomain);
+    } catch (error) {
+      if (isSolanaError(error, SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE)) {
+        throw new SolanaError(
+          SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE,
+          error.context
+        );
+      }
+      if (isSolanaError(error, SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH)) {
+        throw new SolanaError(
+          SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH,
+          error.context
+        );
+      }
+      throw error;
+    }
+  }
+  function offchainMessageApplicationDomain(putativeApplicationDomain) {
+    assertIsOffchainMessageApplicationDomain(putativeApplicationDomain);
+    return putativeApplicationDomain;
+  }
+  function getOffchainMessageApplicationDomainEncoder() {
+    return transformEncoder(
+      getAddressEncoder(),
+      (putativeApplicationDomain) => offchainMessageApplicationDomain(putativeApplicationDomain)
+    );
+  }
+  function getOffchainMessageApplicationDomainDecoder() {
+    return getAddressDecoder();
+  }
+  function getOffchainMessageApplicationDomainCodec() {
+    return combineCodec(getOffchainMessageApplicationDomainEncoder(), getOffchainMessageApplicationDomainDecoder());
+  }
+  var OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES = new Uint8Array([
+    255,
+    115,
+    111,
+    108,
+    97,
+    110,
+    97,
+    32,
+    111,
+    102,
+    102,
+    99,
+    104,
+    97,
+    105,
+    110
+  ]);
+  function getOffchainMessageSigningDomainDecoder() {
+    return getConstantDecoder(OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES);
+  }
+  function getOffchainMessageSigningDomainEncoder() {
+    return getConstantEncoder(OFFCHAIN_MESSAGE_SIGNING_DOMAIN_BYTES);
+  }
+  function getSigningDomainPrefixedDecoder(...fields) {
+    return getHiddenPrefixDecoder(getStructDecoder(fields), [getOffchainMessageSigningDomainDecoder()]);
+  }
+  function getSigningDomainPrefixedEncoder(...fields) {
+    return getHiddenPrefixEncoder(getStructEncoder(fields), [getOffchainMessageSigningDomainEncoder()]);
+  }
+  function getVersionTransformer(fixedVersion) {
+    return (version) => {
+      if (version > 1) {
+        throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
+          unsupportedVersion: version
+        });
+      }
+      if (fixedVersion != null && version !== fixedVersion) {
+        throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION, {
+          actualVersion: version,
+          expectedVersion: fixedVersion
+        });
+      }
+      return version;
+    };
+  }
+  function createOffchainMessagePreambleDecoder(version, ...fields) {
+    return getSigningDomainPrefixedDecoder(
+      ["version", transformDecoder(getU8Decoder(), getVersionTransformer(version))],
+      ...fields
+    );
+  }
+  function createOffchainMessagePreambleEncoder(version, ...fields) {
+    return getSigningDomainPrefixedEncoder(
+      ["version", transformEncoder(getU8Encoder(), getVersionTransformer(version))],
+      ...fields
+    );
+  }
+  function decodeRequiredSignatoryAddresses(bytes) {
+    const { version, bytesAfterVersion } = getSigningDomainPrefixedDecoder(
+      ["version", transformDecoder(getU8Decoder(), getVersionTransformer())],
+      ["bytesAfterVersion", getBytesDecoder()]
+    ).decode(bytes);
+    return offsetDecoder(
+      transformDecoder(getArrayDecoder(getAddressDecoder(), { size: getU8Decoder() }), (signatoryAddresses) => {
+        if (signatoryAddresses.length === 0) {
+          throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO);
+        }
+        return signatoryAddresses;
+      }),
+      {
+        preOffset: ({ preOffset }) => preOffset + (version === 0 ? 32 + 1 : 0)
+      }
+    ).decode(bytesAfterVersion);
+  }
+  function getSignatoriesComparator() {
+    return (x, y) => {
+      if (x.length !== y.length) {
+        return x.length < y.length ? -1 : 1;
+      }
+      for (let ii = 0; ii < x.length; ii++) {
+        if (x[ii] === y[ii]) {
+          continue;
+        } else {
+          return x[ii] < y[ii] ? -1 : 1;
+        }
+      }
+      return 0;
+    };
+  }
+  function getSignaturesToEncode2(signaturesMap) {
+    const signatures = Object.values(signaturesMap);
+    if (signatures.length === 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO);
+    }
+    return signatures.map((signature2) => {
+      if (!signature2) {
+        return new Uint8Array(64).fill(0);
+      }
+      return signature2;
+    });
+  }
+  function getSignaturesEncoder2() {
+    return transformEncoder(
+      getArrayEncoder(fixEncoderSize(getBytesEncoder(), 64), { size: getU8Encoder() }),
+      getSignaturesToEncode2
+    );
+  }
+  function getOffchainMessageEnvelopeEncoder() {
+    return transformEncoder(
+      getStructEncoder([
+        ["signatures", getSignaturesEncoder2()],
+        ["content", getBytesEncoder()]
+      ]),
+      (envelope) => {
+        const signaturesMapAddresses = Object.keys(envelope.signatures).map(address);
+        if (signaturesMapAddresses.length === 0) {
+          throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO);
+        }
+        const signatoryAddresses = decodeAndValidateRequiredSignatoryAddresses(envelope.content);
+        const missingRequiredSigners = [];
+        const unexpectedSigners = [];
+        for (const address2 of signatoryAddresses) {
+          if (!signaturesMapAddresses.includes(address2)) {
+            missingRequiredSigners.push(address2);
+          }
+        }
+        for (const address2 of signaturesMapAddresses) {
+          if (!signatoryAddresses.includes(address2)) {
+            unexpectedSigners.push(address2);
+          }
+        }
+        if (missingRequiredSigners.length || unexpectedSigners.length) {
+          throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH, {
+            missingRequiredSigners,
+            unexpectedSigners
+          });
+        }
+        const orderedSignatureMap = {};
+        for (const address2 of signatoryAddresses) {
+          orderedSignatureMap[address2] = envelope.signatures[address2];
+        }
+        return {
+          ...envelope,
+          signatures: orderedSignatureMap
+        };
+      }
+    );
+  }
+  function getOffchainMessageEnvelopeDecoder() {
+    return transformDecoder(
+      getStructDecoder([
+        ["signatures", getArrayDecoder(fixDecoderSize(getBytesDecoder(), 64), { size: getU8Decoder() })],
+        ["content", getBytesDecoder()]
+      ]),
+      decodePartiallyDecodedOffchainMessageEnvelope
+    );
+  }
+  function getOffchainMessageEnvelopeCodec() {
+    return combineCodec(getOffchainMessageEnvelopeEncoder(), getOffchainMessageEnvelopeDecoder());
+  }
+  function decodePartiallyDecodedOffchainMessageEnvelope(offchainMessageEnvelope) {
+    const { content, signatures } = offchainMessageEnvelope;
+    if (signatures.length === 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO);
+    }
+    const signatoryAddresses = decodeAndValidateRequiredSignatoryAddresses(content);
+    if (signatoryAddresses.length !== signatures.length) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH, {
+        numRequiredSignatures: signatoryAddresses.length,
+        signatoryAddresses,
+        signaturesLength: signatures.length
+      });
+    }
+    const signaturesMap = {};
+    signatoryAddresses.forEach((address2, index) => {
+      const signatureForAddress = signatures[index];
+      if (signatureForAddress.every((b) => b === 0)) {
+        signaturesMap[address2] = null;
+      } else {
+        signaturesMap[address2] = signatureForAddress;
+      }
+    });
+    return Object.freeze({
+      content,
+      signatures: Object.freeze(signaturesMap)
+    });
+  }
+  function decodeAndValidateRequiredSignatoryAddresses(bytes) {
+    const signatoryAddresses = decodeRequiredSignatoryAddresses(bytes);
+    if (signatoryAddresses.length === 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO);
+    }
+    return signatoryAddresses;
+  }
+  var MAX_BODY_BYTES = (
+    // Largest 16-bit unsigned integer
+    65535
+  );
+  var MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE = (
+    // Space remaining in the mininum IPv6 MTU after network header overhead
+    1232
+  );
+  var OffchainMessageContentFormat = /* @__PURE__ */ ((OffchainMessageContentFormat3) => {
+    OffchainMessageContentFormat3[OffchainMessageContentFormat3["RESTRICTED_ASCII_1232_BYTES_MAX"] = 0] = "RESTRICTED_ASCII_1232_BYTES_MAX";
+    OffchainMessageContentFormat3[OffchainMessageContentFormat3["UTF8_1232_BYTES_MAX"] = 1] = "UTF8_1232_BYTES_MAX";
+    OffchainMessageContentFormat3[OffchainMessageContentFormat3["UTF8_65535_BYTES_MAX"] = 2] = "UTF8_65535_BYTES_MAX";
+    return OffchainMessageContentFormat3;
+  })(OffchainMessageContentFormat || {});
+  function assertIsOffchainMessageContentRestrictedAsciiOf1232BytesMax(putativeContent) {
+    if (putativeContent.format !== 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH, {
+        actualMessageFormat: putativeContent.format,
+        expectedMessageFormat: 0
+        /* RESTRICTED_ASCII_1232_BYTES_MAX */
+      });
+    }
+    if (putativeContent.text.length === 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY);
+    }
+    if (isTextRestrictedAscii(putativeContent.text) === false) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE);
+    }
+    const length = getUtf8Encoder().getSizeFromValue(putativeContent.text);
+    if (length > MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED, {
+        actualBytes: length,
+        maxBytes: MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE
+      });
+    }
+  }
+  function isOffchainMessageContentRestrictedAsciiOf1232BytesMax(putativeContent) {
+    if (putativeContent.format !== 0 || putativeContent.text.length === 0 || isTextRestrictedAscii(putativeContent.text) === false) {
+      return false;
+    }
+    const length = getUtf8Encoder().getSizeFromValue(putativeContent.text);
+    return length <= MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE;
+  }
+  function offchainMessageContentRestrictedAsciiOf1232BytesMax(text) {
+    const putativeContent = Object.freeze({
+      format: 0,
+      text
+    });
+    assertIsOffchainMessageContentRestrictedAsciiOf1232BytesMax(putativeContent);
+    return putativeContent;
+  }
+  function assertIsOffchainMessageContentUtf8Of1232BytesMax(putativeContent) {
+    if (putativeContent.text.length === 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY);
+    }
+    if (putativeContent.format !== 1) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH, {
+        actualMessageFormat: putativeContent.format,
+        expectedMessageFormat: 1
+        /* UTF8_1232_BYTES_MAX */
+      });
+    }
+    const length = getUtf8Encoder().getSizeFromValue(putativeContent.text);
+    if (length > MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED, {
+        actualBytes: length,
+        maxBytes: MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE
+      });
+    }
+  }
+  function isOffchainMessageContentUtf8Of1232BytesMax(putativeContent) {
+    if (putativeContent.format !== 1 || putativeContent.text.length === 0) {
+      return false;
+    }
+    const length = getUtf8Encoder().getSizeFromValue(putativeContent.text);
+    return length <= MAX_BODY_BYTES_HARDWARE_WALLET_SIGNABLE;
+  }
+  function offchainMessageContentUtf8Of1232BytesMax(text) {
+    const putativeContent = Object.freeze({
+      format: 1,
+      text
+    });
+    assertIsOffchainMessageContentUtf8Of1232BytesMax(putativeContent);
+    return putativeContent;
+  }
+  function assertIsOffchainMessageContentUtf8Of65535BytesMax(putativeContent) {
+    if (putativeContent.format !== 2) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH, {
+        actualMessageFormat: putativeContent.format,
+        expectedMessageFormat: 2
+        /* UTF8_65535_BYTES_MAX */
+      });
+    }
+    if (putativeContent.text.length === 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY);
+    }
+    const length = getUtf8Encoder().getSizeFromValue(putativeContent.text);
+    if (length > MAX_BODY_BYTES) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED, {
+        actualBytes: length,
+        maxBytes: MAX_BODY_BYTES
+      });
+    }
+  }
+  function isOffchainMessageContentUtf8Of65535BytesMax(putativeContent) {
+    if (putativeContent.format !== 2 || putativeContent.text.length === 0) {
+      return false;
+    }
+    const length = getUtf8Encoder().getSizeFromValue(putativeContent.text);
+    return length <= MAX_BODY_BYTES;
+  }
+  function offchainMessageContentUtf8Of65535BytesMax(text) {
+    const putativeContent = Object.freeze({
+      format: 2,
+      text
+    });
+    assertIsOffchainMessageContentUtf8Of65535BytesMax(putativeContent);
+    return putativeContent;
+  }
+  function isTextRestrictedAscii(putativeRestrictedAsciiString) {
+    return /^[\x20-\x7e]+$/.test(putativeRestrictedAsciiString);
+  }
+  function assertIsOffchainMessageRestrictedAsciiOf1232BytesMax(putativeMessage) {
+    assertIsOffchainMessageContentRestrictedAsciiOf1232BytesMax(putativeMessage.content);
+  }
+  function assertIsOffchainMessageUtf8Of1232BytesMax(putativeMessage) {
+    assertIsOffchainMessageContentUtf8Of1232BytesMax(putativeMessage.content);
+  }
+  function assertIsOffchainMessageUtf8Of65535BytesMax(putativeMessage) {
+    assertIsOffchainMessageContentUtf8Of65535BytesMax(putativeMessage.content);
+  }
+  function getOffchainMessageContentFormatDecoder() {
+    return getEnumDecoder(OffchainMessageContentFormat, {
+      useValuesAsDiscriminators: true
+    });
+  }
+  function getOffchainMessageContentFormatEncoder() {
+    return getEnumEncoder(OffchainMessageContentFormat, {
+      useValuesAsDiscriminators: true
+    });
+  }
+  function getOffchainMessageV0PreambleDecoder() {
+    return createOffchainMessagePreambleDecoder(
+      /* version */
+      0,
+      ["applicationDomain", getOffchainMessageApplicationDomainDecoder()],
+      ["messageFormat", getOffchainMessageContentFormatDecoder()],
+      [
+        "requiredSignatories",
+        transformDecoder(getArrayDecoder(getAddressDecoder(), { size: getU8Decoder() }), (signatoryAddresses) => {
+          if (signatoryAddresses.length === 0) {
+            throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO);
+          }
+          return signatoryAddresses.map((address2) => Object.freeze({ address: address2 }));
+        })
+      ],
+      ["messageLength", getU16Decoder()]
+    );
+  }
+  function getOffchainMessageV0PreambleEncoder() {
+    return createOffchainMessagePreambleEncoder(
+      /* version */
+      0,
+      ["applicationDomain", getOffchainMessageApplicationDomainEncoder()],
+      ["messageFormat", getOffchainMessageContentFormatEncoder()],
+      [
+        "requiredSignatories",
+        transformEncoder(
+          getArrayEncoder(getAddressEncoder(), { size: getU8Encoder() }),
+          (signatoryAddresses) => {
+            if (signatoryAddresses.length === 0) {
+              throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO);
+            }
+            return signatoryAddresses.map(({ address: address2 }) => address2);
+          }
+        )
+      ],
+      ["messageLength", getU16Encoder()]
+    );
+  }
+  function getOffchainMessageV0Decoder() {
+    return transformDecoder(
+      getTupleDecoder([getOffchainMessageV0PreambleDecoder(), getUtf8Decoder()]),
+      ([{ messageLength, messageFormat, requiredSignatories, ...preambleRest }, text]) => {
+        const actualLength = getUtf8Encoder().getSizeFromValue(text);
+        if (messageLength !== actualLength) {
+          throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH, {
+            actualLength,
+            specifiedLength: messageLength
+          });
+        }
+        const offchainMessage = Object.freeze({
+          ...preambleRest,
+          content: Object.freeze({
+            format: messageFormat,
+            text
+          }),
+          requiredSignatories: Object.freeze(requiredSignatories)
+        });
+        switch (messageFormat) {
+          case 0: {
+            assertIsOffchainMessageRestrictedAsciiOf1232BytesMax(offchainMessage);
+            return offchainMessage;
+          }
+          case 1: {
+            assertIsOffchainMessageUtf8Of1232BytesMax(offchainMessage);
+            return offchainMessage;
+          }
+          case 2: {
+            assertIsOffchainMessageUtf8Of65535BytesMax(offchainMessage);
+            return offchainMessage;
+          }
+          default: {
+            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE, {
+              unexpectedValue: messageFormat
+            });
+          }
+        }
+      }
+    );
+  }
+  function getOffchainMessageV0Encoder() {
+    return transformEncoder(
+      getTupleEncoder([getOffchainMessageV0PreambleEncoder(), getUtf8Encoder()]),
+      (offchainMessage) => {
+        const { content, ...preamble } = offchainMessage;
+        switch (offchainMessage.content.format) {
+          case 0: {
+            assertIsOffchainMessageRestrictedAsciiOf1232BytesMax(offchainMessage);
+            break;
+          }
+          case 1: {
+            assertIsOffchainMessageUtf8Of1232BytesMax(offchainMessage);
+            break;
+          }
+          case 2: {
+            assertIsOffchainMessageUtf8Of65535BytesMax(offchainMessage);
+            break;
+          }
+          default: {
+            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE, {
+              unexpectedValue: offchainMessage.content
+            });
+          }
+        }
+        const messageLength = getUtf8Encoder().getSizeFromValue(content.text);
+        const compiledPreamble = {
+          ...preamble,
+          messageFormat: content.format,
+          messageLength
+        };
+        return [compiledPreamble, content.text];
+      }
+    );
+  }
+  function getOffchainMessageV0Codec() {
+    return combineCodec(getOffchainMessageV0Encoder(), getOffchainMessageV0Decoder());
+  }
+  function getOffchainMessageV1PreambleDecoder() {
+    return createOffchainMessagePreambleDecoder(
+      /* version */
+      1,
+      [
+        "requiredSignatories",
+        transformDecoder(
+          getArrayDecoder(fixDecoderSize(getBytesDecoder(), 32), { size: getU8Decoder() }),
+          (signatoryAddressesBytes) => {
+            if (signatoryAddressesBytes.length === 0) {
+              throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO);
+            }
+            const comparator = getSignatoriesComparator();
+            for (let ii = 0; ii < signatoryAddressesBytes.length - 1; ii++) {
+              switch (comparator(signatoryAddressesBytes[ii], signatoryAddressesBytes[ii + 1])) {
+                case 0:
+                  throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE);
+                case 1:
+                  throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED);
+              }
+            }
+            const addressDecoder = getAddressDecoder();
+            return signatoryAddressesBytes.map(
+              (addressBytes) => Object.freeze({
+                address: addressDecoder.decode(addressBytes)
+              })
+            );
+          }
+        )
+      ]
+    );
+  }
+  function getOffchainMessageV1PreambleEncoder() {
+    return createOffchainMessagePreambleEncoder(
+      /* version */
+      1,
+      [
+        "requiredSignatories",
+        transformEncoder(
+          transformEncoder(
+            getArrayEncoder(getBytesEncoder(), { size: getU8Encoder() }),
+            (signatoryAddressesBytes) => {
+              return signatoryAddressesBytes.toSorted(getSignatoriesComparator());
+            }
+          ),
+          (signatoryAddresses) => {
+            if (signatoryAddresses.length === 0) {
+              throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO);
+            }
+            const seenSignatories = /* @__PURE__ */ new Set();
+            for (const { address: address2 } of signatoryAddresses) {
+              if (seenSignatories.has(address2)) {
+                throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE);
+              }
+              seenSignatories.add(address2);
+            }
+            const addressEncoder = getAddressEncoder();
+            return signatoryAddresses.map(({ address: address2 }) => addressEncoder.encode(address2));
+          }
+        )
+      ]
+    );
+  }
+  function getOffchainMessageV1Decoder() {
+    return transformDecoder(
+      getTupleDecoder([getOffchainMessageV1PreambleDecoder(), getUtf8Decoder()]),
+      ([{ requiredSignatories, ...preambleRest }, text]) => {
+        if (text.length === 0) {
+          throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY);
+        }
+        return Object.freeze({
+          ...preambleRest,
+          content: text,
+          requiredSignatories: Object.freeze(requiredSignatories)
+        });
+      }
+    );
+  }
+  function getOffchainMessageV1Encoder() {
+    return transformEncoder(
+      getTupleEncoder([getOffchainMessageV1PreambleEncoder(), getUtf8Encoder()]),
+      (offchainMessage) => {
+        const { content, ...compiledPreamble } = offchainMessage;
+        if (content.length === 0) {
+          throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY);
+        }
+        return [compiledPreamble, content];
+      }
+    );
+  }
+  function getOffchainMessageV1Codec() {
+    return combineCodec(getOffchainMessageV1Encoder(), getOffchainMessageV1Decoder());
+  }
+  function getOffchainMessageDecoder() {
+    return createDecoder({
+      read(bytes, offset) {
+        const version = getHiddenPrefixDecoder(getU8Decoder(), [
+          // Discard the signing domain
+          getOffchainMessageSigningDomainDecoder()
+        ]).decode(bytes, offset);
+        switch (version) {
+          case 0:
+            return getOffchainMessageV0Decoder().read(bytes, offset);
+          case 1:
+            return getOffchainMessageV1Decoder().read(bytes, offset);
+          default:
+            throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
+              unsupportedVersion: version
+            });
+        }
+      }
+    });
+  }
+  function getOffchainMessageEncoder() {
+    return createEncoder({
+      getSizeFromValue: (offchainMessage) => {
+        const { version } = offchainMessage;
+        switch (version) {
+          case 0:
+            return getOffchainMessageV0Encoder().getSizeFromValue(offchainMessage);
+          case 1:
+            return getOffchainMessageV1Encoder().getSizeFromValue(offchainMessage);
+          default:
+            throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
+              unsupportedVersion: version
+            });
+        }
+      },
+      write: (offchainMessage, bytes, offset) => {
+        const { version } = offchainMessage;
+        switch (version) {
+          case 0:
+            return getOffchainMessageV0Encoder().write(offchainMessage, bytes, offset);
+          case 1:
+            return getOffchainMessageV1Encoder().write(offchainMessage, bytes, offset);
+          default:
+            throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED, {
+              unsupportedVersion: version
+            });
+        }
+      }
+    });
+  }
+  function getOffchainMessageCodec() {
+    return combineCodec(getOffchainMessageEncoder(), getOffchainMessageDecoder());
+  }
+  function compileOffchainMessageEnvelopeUsingEncoder(offchainMessage, encoder) {
+    const offchainMessageBytes = encoder.encode(offchainMessage);
+    const signatures = {};
+    for (const { address: address2 } of offchainMessage.requiredSignatories) {
+      signatures[address2] = null;
+    }
+    return Object.freeze({
+      content: offchainMessageBytes,
+      signatures: Object.freeze(signatures)
+    });
+  }
+  function compileOffchainMessageV0Envelope(offchainMessage) {
+    return compileOffchainMessageEnvelopeUsingEncoder(offchainMessage, getOffchainMessageV0Encoder());
+  }
+  function compileOffchainMessageV1Envelope(offchainMessage) {
+    return compileOffchainMessageEnvelopeUsingEncoder(offchainMessage, getOffchainMessageV1Encoder());
+  }
+  function compileOffchainMessageEnvelope(offchainMessage) {
+    const { version } = offchainMessage;
+    switch (version) {
+      case 0:
+        return compileOffchainMessageV0Envelope(offchainMessage);
+      case 1:
+        return compileOffchainMessageV1Envelope(offchainMessage);
+      default:
+        throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE, {
+          unexpectedValue: version
+        });
+    }
+  }
+  async function partiallySignOffchainMessageEnvelope(keyPairs, offchainMessageEnvelope) {
+    let newSignatures;
+    let unexpectedSigners;
+    const requiredSignatoryAddresses = decodeRequiredSignatoryAddresses(offchainMessageEnvelope.content);
+    await Promise.all(
+      keyPairs.map(async (keyPair) => {
+        const address2 = await getAddressFromPublicKey(keyPair.publicKey);
+        if (!requiredSignatoryAddresses.includes(address2)) {
+          unexpectedSigners || (unexpectedSigners = /* @__PURE__ */ new Set());
+          unexpectedSigners.add(address2);
+          return;
+        }
+        if (unexpectedSigners) {
+          return;
+        }
+        const existingSignature = offchainMessageEnvelope.signatures[address2];
+        const newSignature = await signBytes(keyPair.privateKey, offchainMessageEnvelope.content);
+        if (existingSignature != null && bytesEqual(newSignature, existingSignature)) {
+          return;
+        }
+        newSignatures || (newSignatures = {});
+        newSignatures[address2] = newSignature;
+      })
+    );
+    if (unexpectedSigners && unexpectedSigners.size > 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE, {
+        expectedAddresses: requiredSignatoryAddresses,
+        unexpectedAddresses: [...unexpectedSigners]
+      });
+    }
+    if (!newSignatures) {
+      return offchainMessageEnvelope;
+    }
+    return Object.freeze({
+      ...offchainMessageEnvelope,
+      signatures: Object.freeze({
+        ...offchainMessageEnvelope.signatures,
+        ...newSignatures
+      })
+    });
+  }
+  async function signOffchainMessageEnvelope(keyPairs, offchainMessageEnvelope) {
+    const out = await partiallySignOffchainMessageEnvelope(keyPairs, offchainMessageEnvelope);
+    assertIsFullySignedOffchainMessageEnvelope(out);
+    Object.freeze(out);
+    return out;
+  }
+  function isFullySignedOffchainMessageEnvelope(offchainMessage) {
+    return Object.entries(offchainMessage.signatures).every(([_, signatureBytes2]) => !!signatureBytes2);
+  }
+  function assertIsFullySignedOffchainMessageEnvelope(offchainMessage) {
+    const missingSigs = [];
+    Object.entries(offchainMessage.signatures).forEach(([address2, signatureBytes2]) => {
+      if (!signatureBytes2) {
+        missingSigs.push(address2);
+      }
+    });
+    if (missingSigs.length > 0) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING, {
+        addresses: missingSigs
+      });
+    }
+  }
+  async function verifyOffchainMessageEnvelope(offchainMessageEnvelope) {
+    let errorContext;
+    const requiredSignatories = decodeRequiredSignatoryAddresses(offchainMessageEnvelope.content);
+    await Promise.all(
+      requiredSignatories.map(async (address2) => {
+        const signature2 = offchainMessageEnvelope.signatures[address2];
+        if (signature2 == null) {
+          errorContext || (errorContext = {});
+          errorContext.signatoriesWithMissingSignatures || (errorContext.signatoriesWithMissingSignatures = []);
+          errorContext.signatoriesWithMissingSignatures.push(address2);
+        } else {
+          const publicKey = await getPublicKeyFromAddress(address2);
+          if (await verifySignature(publicKey, signature2, offchainMessageEnvelope.content)) {
+            return true;
+          } else {
+            errorContext || (errorContext = {});
+            errorContext.signatoriesWithInvalidSignatures || (errorContext.signatoriesWithInvalidSignatures = []);
+            errorContext.signatoriesWithInvalidSignatures.push(address2);
+          }
+        }
+      })
+    );
+    if (errorContext) {
+      throw new SolanaError(SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE, errorContext);
+    }
+  }
+
   // ../programs/dist/index.browser.mjs
   function isProgramError(error, transactionMessage, programAddress, code) {
     var _a;
@@ -6210,7 +7065,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           ...config.headers ? normalizeHeaders2(config.headers) : void 0,
           ...{
             // Keep these headers lowercase so they will override any user-supplied headers above.
-            "solana-client": `js/${"5.0.1-canary-20251119203851"}`
+            "solana-client": `js/${"5.1.0-canary-20251204140906"}`
           }
         }
       }),
@@ -7198,7 +8053,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       );
     }
     const { intervalMs, ...rest } = config;
-    const createDefaultRpcSubscriptionsChannel = ({ abortSignal }) => {
+    const createDefaultRpcSubscriptionsChannel = (({ abortSignal }) => {
       var _a2;
       return createWebSocketChannel({
         ...rest,
@@ -7214,7 +8069,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
           intervalMs: intervalMs != null ? intervalMs : 5e3
         })
       );
-    };
+    });
     return getChannelPoolingChannelCreator(createDefaultRpcSubscriptionsChannel, {
       maxSubscriptionsPerChannel: (_a = config.maxSubscriptionsPerChannel) != null ? _a : (
         /**
@@ -7292,10 +8147,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
   }
   function createRpcSubscriptionsTransportFromChannelCreator(createChannel) {
-    return async ({ execute, signal }) => {
+    return (async ({ execute, signal }) => {
       const channel = await createChannel({ abortSignal: signal });
       return await execute({ channel, signal });
-    };
+    });
   }
   function createSolanaRpcSubscriptionsImpl(clusterUrl, config) {
     const transport = createDefaultRpcSubscriptionsTransport({
@@ -7497,6 +8352,60 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
     return Object.freeze(out);
   }
+  function getSignersFromOffchainMessage({
+    requiredSignatories
+  }) {
+    const messageSigners = requiredSignatories.filter(isMessageSigner);
+    return deduplicateSigners(messageSigners);
+  }
+  async function partiallySignOffchainMessageWithSigners(offchainMessage, config) {
+    const { partialSigners, modifyingSigners } = categorizeMessageSigners(
+      getSignersFromOffchainMessage(offchainMessage)
+    );
+    return await signModifyingAndPartialMessageSigners(offchainMessage, modifyingSigners, partialSigners, config);
+  }
+  async function signOffchainMessageWithSigners(offchainMessage, config) {
+    const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage, config);
+    assertIsFullySignedOffchainMessageEnvelope(signedOffchainMessageEnvelope);
+    return signedOffchainMessageEnvelope;
+  }
+  function categorizeMessageSigners(signers) {
+    const modifyingSigners = identifyMessageModifyingSigners(signers);
+    const partialSigners = signers.filter(isMessagePartialSigner).filter((signer) => !modifyingSigners.includes(signer));
+    return Object.freeze({ modifyingSigners, partialSigners });
+  }
+  function identifyMessageModifyingSigners(signers) {
+    const modifyingSigners = signers.filter(isMessageModifyingSigner);
+    if (modifyingSigners.length === 0) return [];
+    const nonPartialSigners = modifyingSigners.filter((signer) => !isMessagePartialSigner(signer));
+    if (nonPartialSigners.length > 0) return nonPartialSigners;
+    return [modifyingSigners[0]];
+  }
+  async function signModifyingAndPartialMessageSigners(offchainMessage, modifyingSigners = [], partialSigners = [], config) {
+    var _a, _b;
+    const offchainMessageEnvelope = compileOffchainMessageEnvelope(offchainMessage);
+    const modifiedOffchainMessage = await modifyingSigners.reduce(async (offchainMessageEnvelope2, modifyingSigner) => {
+      var _a2;
+      (_a2 = config == null ? void 0 : config.abortSignal) == null ? void 0 : _a2.throwIfAborted();
+      const [message] = await modifyingSigner.modifyAndSignMessages([await offchainMessageEnvelope2], config);
+      return Object.freeze(message);
+    }, Promise.resolve(offchainMessageEnvelope));
+    (_a = config == null ? void 0 : config.abortSignal) == null ? void 0 : _a.throwIfAborted();
+    const signatureDictionaries = await Promise.all(
+      partialSigners.map(async (partialSigner) => {
+        const [signatures] = await partialSigner.signMessages([modifiedOffchainMessage], config);
+        return signatures;
+      })
+    );
+    return Object.freeze({
+      ...modifiedOffchainMessage,
+      signatures: Object.freeze(
+        signatureDictionaries.reduce((signatures, signatureDictionary) => {
+          return { ...signatures, ...signatureDictionary };
+        }, (_b = modifiedOffchainMessage.signatures) != null ? _b : {})
+      )
+    });
+  }
   function isTransactionMessageWithSingleSendingSigner(transaction) {
     try {
       assertIsTransactionMessageWithSingleSendingSigner(transaction);
@@ -8123,6 +9032,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.DEFAULT_RPC_SUBSCRIPTIONS_CONFIG = DEFAULT_RPC_SUBSCRIPTIONS_CONFIG;
   exports.Endian = Endian;
   exports.MAX_SUPPORTED_TRANSACTION_VERSION = MAX_SUPPORTED_TRANSACTION_VERSION;
+  exports.OffchainMessageContentFormat = OffchainMessageContentFormat;
   exports.SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND = SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND;
   exports.SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED = SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED;
   exports.SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT = SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT;
@@ -8272,6 +9182,24 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR = SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR;
   exports.SOLANA_ERROR__MALFORMED_NUMBER_STRING = SOLANA_ERROR__MALFORMED_NUMBER_STRING;
   exports.SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND = SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE = SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE = SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH = SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH = SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED = SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH = SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH = SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY = SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO = SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO = SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH = SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE = SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED = SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE = SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING = SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE = SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION = SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION;
+  exports.SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED = SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED;
   exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN;
   exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED;
   exports.SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED = SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED;
@@ -8388,6 +9316,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.assertIsAddress = assertIsAddress;
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsFixedSize = assertIsFixedSize;
+  exports.assertIsFullySignedOffchainMessageEnvelope = assertIsFullySignedOffchainMessageEnvelope;
   exports.assertIsFullySignedTransaction = assertIsFullySignedTransaction;
   exports.assertIsInstructionForProgram = assertIsInstructionForProgram;
   exports.assertIsInstructionWithAccounts = assertIsInstructionWithAccounts;
@@ -8398,6 +9327,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.assertIsMessagePartialSigner = assertIsMessagePartialSigner;
   exports.assertIsMessageSigner = assertIsMessageSigner;
   exports.assertIsOffCurveAddress = assertIsOffCurveAddress;
+  exports.assertIsOffchainMessageApplicationDomain = assertIsOffchainMessageApplicationDomain;
+  exports.assertIsOffchainMessageContentRestrictedAsciiOf1232BytesMax = assertIsOffchainMessageContentRestrictedAsciiOf1232BytesMax;
+  exports.assertIsOffchainMessageContentUtf8Of1232BytesMax = assertIsOffchainMessageContentUtf8Of1232BytesMax;
+  exports.assertIsOffchainMessageContentUtf8Of65535BytesMax = assertIsOffchainMessageContentUtf8Of65535BytesMax;
+  exports.assertIsOffchainMessageRestrictedAsciiOf1232BytesMax = assertIsOffchainMessageRestrictedAsciiOf1232BytesMax;
+  exports.assertIsOffchainMessageUtf8Of1232BytesMax = assertIsOffchainMessageUtf8Of1232BytesMax;
+  exports.assertIsOffchainMessageUtf8Of65535BytesMax = assertIsOffchainMessageUtf8Of65535BytesMax;
   exports.assertIsProgramDerivedAddress = assertIsProgramDerivedAddress;
   exports.assertIsSendableTransaction = assertIsSendableTransaction;
   exports.assertIsSignature = assertIsSignature;
@@ -8421,9 +9357,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.assertValidBaseString = assertValidBaseString;
   exports.assertValidNumberOfItemsForCodec = assertValidNumberOfItemsForCodec;
   exports.blockhash = blockhash;
+  exports.bytesEqual = bytesEqual;
   exports.canceledSingleTransactionPlanResult = canceledSingleTransactionPlanResult;
   exports.combineCodec = combineCodec;
   exports.commitmentComparator = commitmentComparator;
+  exports.compileOffchainMessageEnvelope = compileOffchainMessageEnvelope;
+  exports.compileOffchainMessageV0Envelope = compileOffchainMessageV0Envelope;
+  exports.compileOffchainMessageV1Envelope = compileOffchainMessageV1Envelope;
   exports.compileTransaction = compileTransaction;
   exports.compileTransactionMessage = compileTransactionMessage;
   exports.compressTransactionMessageUsingAddressLookupTables = compressTransactionMessageUsingAddressLookupTables;
@@ -8479,6 +9419,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.fixCodecSize = fixCodecSize;
   exports.fixDecoderSize = fixDecoderSize;
   exports.fixEncoderSize = fixEncoderSize;
+  exports.flattenTransactionPlanResult = flattenTransactionPlanResult;
   exports.generateKeyPair = generateKeyPair;
   exports.generateKeyPairSigner = generateKeyPairSigner;
   exports.getAddressCodec = getAddressCodec;
@@ -8580,6 +9521,21 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.getNullableCodec = getNullableCodec;
   exports.getNullableDecoder = getNullableDecoder;
   exports.getNullableEncoder = getNullableEncoder;
+  exports.getOffchainMessageApplicationDomainCodec = getOffchainMessageApplicationDomainCodec;
+  exports.getOffchainMessageApplicationDomainDecoder = getOffchainMessageApplicationDomainDecoder;
+  exports.getOffchainMessageApplicationDomainEncoder = getOffchainMessageApplicationDomainEncoder;
+  exports.getOffchainMessageCodec = getOffchainMessageCodec;
+  exports.getOffchainMessageDecoder = getOffchainMessageDecoder;
+  exports.getOffchainMessageEncoder = getOffchainMessageEncoder;
+  exports.getOffchainMessageEnvelopeCodec = getOffchainMessageEnvelopeCodec;
+  exports.getOffchainMessageEnvelopeDecoder = getOffchainMessageEnvelopeDecoder;
+  exports.getOffchainMessageEnvelopeEncoder = getOffchainMessageEnvelopeEncoder;
+  exports.getOffchainMessageV0Codec = getOffchainMessageV0Codec;
+  exports.getOffchainMessageV0Decoder = getOffchainMessageV0Decoder;
+  exports.getOffchainMessageV0Encoder = getOffchainMessageV0Encoder;
+  exports.getOffchainMessageV1Codec = getOffchainMessageV1Codec;
+  exports.getOffchainMessageV1Decoder = getOffchainMessageV1Decoder;
+  exports.getOffchainMessageV1Encoder = getOffchainMessageV1Encoder;
   exports.getOptionCodec = getOptionCodec;
   exports.getOptionDecoder = getOptionDecoder;
   exports.getOptionEncoder = getOptionEncoder;
@@ -8599,6 +9555,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.getShortU16Encoder = getShortU16Encoder;
   exports.getSignatureFromTransaction = getSignatureFromTransaction;
   exports.getSignersFromInstruction = getSignersFromInstruction;
+  exports.getSignersFromOffchainMessage = getSignersFromOffchainMessage;
   exports.getSignersFromTransactionMessage = getSignersFromTransactionMessage;
   exports.getSolanaErrorFromInstructionError = getSolanaErrorFromInstructionError;
   exports.getSolanaErrorFromJsonRpcError = getSolanaErrorFromJsonRpcError;
@@ -8646,6 +9603,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
   exports.isBlockhash = isBlockhash;
   exports.isFixedSize = isFixedSize;
+  exports.isFullySignedOffchainMessageEnvelope = isFullySignedOffchainMessageEnvelope;
   exports.isFullySignedTransaction = isFullySignedTransaction;
   exports.isInstructionForProgram = isInstructionForProgram;
   exports.isInstructionWithAccounts = isInstructionWithAccounts;
@@ -8658,6 +9616,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.isMessageSigner = isMessageSigner;
   exports.isNone = isNone;
   exports.isOffCurveAddress = isOffCurveAddress;
+  exports.isOffchainMessageApplicationDomain = isOffchainMessageApplicationDomain;
+  exports.isOffchainMessageContentRestrictedAsciiOf1232BytesMax = isOffchainMessageContentRestrictedAsciiOf1232BytesMax;
+  exports.isOffchainMessageContentUtf8Of1232BytesMax = isOffchainMessageContentUtf8Of1232BytesMax;
+  exports.isOffchainMessageContentUtf8Of65535BytesMax = isOffchainMessageContentUtf8Of65535BytesMax;
   exports.isOption = isOption;
   exports.isProgramDerivedAddress = isProgramDerivedAddress;
   exports.isProgramError = isProgramError;
@@ -8692,6 +9654,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.nonDivisibleSequentialTransactionPlanResult = nonDivisibleSequentialTransactionPlanResult;
   exports.none = none;
   exports.offCurveAddress = offCurveAddress;
+  exports.offchainMessageApplicationDomain = offchainMessageApplicationDomain;
+  exports.offchainMessageContentRestrictedAsciiOf1232BytesMax = offchainMessageContentRestrictedAsciiOf1232BytesMax;
+  exports.offchainMessageContentUtf8Of1232BytesMax = offchainMessageContentUtf8Of1232BytesMax;
+  exports.offchainMessageContentUtf8Of65535BytesMax = offchainMessageContentUtf8Of65535BytesMax;
   exports.offsetCodec = offsetCodec;
   exports.offsetDecoder = offsetDecoder;
   exports.offsetEncoder = offsetEncoder;
@@ -8709,6 +9675,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.parseBase58RpcAccount = parseBase58RpcAccount;
   exports.parseBase64RpcAccount = parseBase64RpcAccount;
   exports.parseJsonRpcAccount = parseJsonRpcAccount;
+  exports.partiallySignOffchainMessageEnvelope = partiallySignOffchainMessageEnvelope;
+  exports.partiallySignOffchainMessageWithSigners = partiallySignOffchainMessageWithSigners;
   exports.partiallySignTransaction = partiallySignTransaction;
   exports.partiallySignTransactionMessageWithSigners = partiallySignTransactionMessageWithSigners;
   exports.pipe = pipe;
@@ -8734,6 +9702,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.setTransactionMessageLifetimeUsingDurableNonce = setTransactionMessageLifetimeUsingDurableNonce;
   exports.signAndSendTransactionMessageWithSigners = signAndSendTransactionMessageWithSigners;
   exports.signBytes = signBytes;
+  exports.signOffchainMessageEnvelope = signOffchainMessageEnvelope;
+  exports.signOffchainMessageWithSigners = signOffchainMessageWithSigners;
   exports.signTransaction = signTransaction;
   exports.signTransactionMessageWithSigners = signTransactionMessageWithSigners;
   exports.signature = signature;
@@ -8744,6 +9714,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.stringifiedBigInt = stringifiedBigInt;
   exports.stringifiedNumber = stringifiedNumber;
   exports.successfulSingleTransactionPlanResult = successfulSingleTransactionPlanResult;
+  exports.successfulSingleTransactionPlanResultFromSignature = successfulSingleTransactionPlanResultFromSignature;
+  exports.summarizeTransactionPlanResult = summarizeTransactionPlanResult;
   exports.testnet = testnet;
   exports.transformChannelInboundMessages = transformChannelInboundMessages;
   exports.transformChannelOutboundMessages = transformChannelOutboundMessages;
@@ -8755,6 +9727,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.unwrapOptionRecursively = unwrapOptionRecursively;
   exports.upgradeRoleToSigner = upgradeRoleToSigner;
   exports.upgradeRoleToWritable = upgradeRoleToWritable;
+  exports.verifyOffchainMessageEnvelope = verifyOffchainMessageEnvelope;
   exports.verifySignature = verifySignature;
   exports.wrapNullable = wrapNullable;