@sovereign-sdk/web3 0.14.0 → 0.15.0

package/dist/index.js

@@ -40,6 +40,7 @@ __export(src_exports, {
   StandardRollup: () => StandardRollup,
   VersionMismatchError: () => VersionMismatchError,
   addressFromPublicKey: () => addressFromPublicKey,
+  chainHashFragment: () => chainHashFragment,
   createSolanaSignableRollup: () => createSolanaSignableRollup,
   createStandardRollup: () => createStandardRollup,
   standardTypeBuilder: () => standardTypeBuilder
@@ -169,13 +170,29 @@ var Rollup = class {
    * Retrieve dedup information about the provided address.
    *
    * @param publicKey - The public key to dedup.
-   * TODO: How to add param for generation explicitly
+   * TODO: How to request a specific uniqueness strategy explicitly
    */
   async dedup(publicKey) {
-    const credentialId = (0, import_utils2.bytesToHex)(publicKey);
+    return this.dedupByCredentialId((0, import_utils2.bytesToHex)(publicKey));
+  }
+  /**
+   * Retrieve dedup information about the provided credential ID.
+   */
+  async dedupByCredentialId(credentialId) {
     const response = await this.rollup.addresses.dedup(credentialId);
     return response;
   }
+  /**
+   * Builds an unsigned transaction for the provided runtime call.
+   */
+  async buildUnsignedTransaction(runtimeCall, params) {
+    const context = {
+      runtimeCall,
+      rollup: this,
+      overrides: params?.overrides ?? {}
+    };
+    return this._typeBuilder.unsignedTransaction(context);
+  }
   /**
    * Submits a transaction to the rollup.
    *
@@ -233,12 +250,9 @@ var Rollup = class {
    * @param {SovereignClient.RequestOptions} options - The options for the request.
    */
   async call(runtimeCall, { signer, overrides }, options) {
-    const context = {
-      runtimeCall,
-      rollup: this,
-      overrides: overrides ?? {}
-    };
-    const unsignedTx = await this._typeBuilder.unsignedTransaction(context);
+    const unsignedTx = await this.buildUnsignedTransaction(runtimeCall, {
+      overrides
+    });
     return this.signAndSubmitTransaction(
       unsignedTx,
       {
@@ -259,18 +273,15 @@ var Rollup = class {
    * @returns A promise that resolves to the signed transaction.
    */
   async prepareCall(runtimeCall, { signer, overrides }) {
-    const context = {
-      runtimeCall,
-      rollup: this,
-      overrides: overrides ?? {}
-    };
-    const unsignedTx = await this._typeBuilder.unsignedTransaction(context);
+    const unsignedTx = await this.buildUnsignedTransaction(runtimeCall, {
+      overrides
+    });
     return this.signTransaction(unsignedTx, signer);
   }
   /**
    * Signs an unsigned transaction using the provided signer.
-   * Creates a signature by combining the serialized unsigned transaction with the chain hash,
-   * then constructs a fully signed transaction.
+   * Creates a signature over the serialized transaction signing payload, then constructs a fully
+   * signed transaction.
    *
    * @param unsignedTx - The unsigned transaction to sign.
    * @param signer - The signer to use for signing the transaction.
@@ -278,11 +289,15 @@ var Rollup = class {
    */
   async signTransaction(unsignedTx, signer) {
     const serializer = await this.serializer();
-    const serializedUnsignedTx = serializer.serializeUnsignedTx(unsignedTx);
-    const chainHash = await this.chainHash();
-    const signature = await signer.sign(
-      new Uint8Array([...serializedUnsignedTx, ...chainHash])
+    const transactionSigningPayload = await this._typeBuilder.transactionSigningPayload({
+      unsignedTx,
+      chainHash: await this.chainHash(),
+      rollup: this
+    });
+    const signingBytes = serializer.serializeSigningPayload(
+      transactionSigningPayload
     );
+    const signature = await signer.sign(signingBytes);
     const publicKey = await signer.publicKey();
     const context = {
       unsignedTx,
@@ -370,10 +385,12 @@ var Rollup = class {
   }
 };
 function isVersionMismatchError(e) {
-  if (
-    // biome-ignore lint/suspicious/noExplicitAny: yolo
-    e.error?.details?.error?.includes("Signature verification failed")
-  ) {
+  const details = e.error?.details;
+  if (details?.code === "invalid_chain_hash_fragment") {
+    return true;
+  }
+  const error = details?.error;
+  if (typeof error === "string" && error.includes("Signature verification failed")) {
     return true;
   }
   return false;
@@ -383,6 +400,36 @@ function isVersionMismatchError(e) {
 var import_client2 = __toESM(require("@sovereign-sdk/client"));
 var import_serializers = require("@sovereign-sdk/serializers");
 var import_utils3 = require("@sovereign-sdk/utils");
+
+// src/rollup/chain-hash.ts
+function chainHashFragment(chainHash) {
+  if (chainHash.length < 8) {
+    throw new Error("chain hash must contain at least 8 bytes");
+  }
+  return new DataView(
+    chainHash.buffer,
+    chainHash.byteOffset,
+    chainHash.byteLength
+  ).getBigUint64(0, true).toString();
+}
+function refreshChainHashFragment(unsignedTx, chainHash) {
+  unsignedTx.details = {
+    ...unsignedTx.details,
+    chain_hash_fragment: chainHashFragment(chainHash)
+  };
+  return unsignedTx;
+}
+function assertChainHashFragment(unsignedTx, chainHash) {
+  const expectedFragment = chainHashFragment(chainHash);
+  const actualFragment = unsignedTx.details.chain_hash_fragment;
+  if (actualFragment !== expectedFragment) {
+    throw new Error(
+      `Cannot sign transaction: chain_hash_fragment ${actualFragment} does not match the current chain hash fragment ${expectedFragment}`
+    );
+  }
+}
+
+// src/rollup/standard-rollup.ts
 var useOrFetchUniqueness = async ({
   overrides
 }) => {
@@ -395,7 +442,7 @@ function standardTypeBuilder() {
   return {
     async unsignedTransaction(context) {
       const { rollup, runtimeCall } = context;
-      const { uniqueness: _, ...overrides } = context.overrides;
+      const overrides = context.overrides;
       const uniqueness = await useOrFetchUniqueness(context);
       const details = {
         ...rollup.context.defaultTxDetails,
@@ -404,7 +451,8 @@ function standardTypeBuilder() {
       return {
         runtime_call: runtimeCall,
         uniqueness,
-        details
+        details,
+        address_override: overrides.address_override ?? null
       };
     },
     async transaction({
@@ -419,10 +467,67 @@ function standardTypeBuilder() {
           ...unsignedTx
         }
       };
+    },
+    async transactionSigningPayload({
+      unsignedTx,
+      chainHash
+    }) {
+      const normalizedUnsignedTx = refreshChainHashFragment(
+        unsignedTx,
+        chainHash
+      );
+      return {
+        V0: {
+          ...normalizedUnsignedTx,
+          chain_hash: Array.from(chainHash)
+        }
+      };
     }
   };
 }
 var StandardRollup = class extends Rollup {
+  updateDefaultChainHashFragment(chainHash) {
+    this.context.defaultTxDetails.chain_hash_fragment = chainHashFragment(chainHash);
+  }
+  async credentialAddressFromId(credentialId) {
+    if (this.context.credentialIdToAddress) {
+      const serializer = await this.serializer();
+      return this.context.credentialIdToAddress(
+        credentialId,
+        serializer.schema
+      );
+    }
+    return addressFromPublicKey(credentialId, "sov");
+  }
+  async submitTransaction(transaction, options) {
+    try {
+      return await super.submitTransaction(transaction, options);
+    } catch (error) {
+      if (error instanceof VersionMismatchError) {
+        this.updateDefaultChainHashFragment(await super.chainHash());
+      }
+      throw error;
+    }
+  }
+  async hydrate() {
+    await super.hydrate();
+    this.updateDefaultChainHashFragment(await super.chainHash());
+  }
+  async multisigSigningBytes(unsignedTx, multisig) {
+    const serializer = await this.serializer();
+    const chainHash = await this.chainHash();
+    assertChainHashFragment(unsignedTx, chainHash);
+    const signingPayload = {
+      V1: {
+        ...unsignedTx,
+        chain_hash: Array.from(chainHash),
+        credential_address: await this.credentialAddressFromId(
+          multisig.getMultisigAddress()
+        )
+      }
+    };
+    return serializer.serializeSigningPayload(signingPayload);
+  }
   /**
    * Simulates a runtime call transaction.
    *
@@ -430,11 +535,15 @@ var StandardRollup = class extends Rollup {
    *
    * @param runtimeMessage - The runtime message to call.
    */
-  async simulate(runtimeMessage, { signer }) {
+  async simulate(runtimeMessage, { signer, ...params }) {
     const publicKey = await signer.publicKey();
     const sender = (0, import_utils3.bytesToHex)(publicKey);
     const call = runtimeMessage;
-    return this.rollup.simulate({ sender, call });
+    return this.rollup.simulate({
+      ...params,
+      sender,
+      call
+    });
   }
 };
 var DEFAULT_TX_DETAILS = {
@@ -442,26 +551,24 @@ var DEFAULT_TX_DETAILS = {
   max_fee: "100000000",
   gas_limit: null
 };
-async function buildContext(client, context) {
+function buildContext(context, credentialIdToAddress) {
   const defaultTxDetails = {
     ...DEFAULT_TX_DETAILS,
     ...context?.defaultTxDetails
   };
-  if (!defaultTxDetails.chain_id) {
-    const { chain_id } = await client.rollup.constants();
-    defaultTxDetails.chain_id = chain_id;
-  }
   return {
-    defaultTxDetails
+    ...context,
+    defaultTxDetails,
+    credentialIdToAddress: credentialIdToAddress ?? context?.credentialIdToAddress
   };
 }
 async function createStandardRollup(rollupConfig, typeBuilderOverrides) {
   const config = rollupConfig ?? {};
   const client = config.client ?? new import_client2.default({ baseURL: config.url });
   const getSerializer = config.getSerializer ?? ((schema) => new import_serializers.JsSerializer(schema));
-  const context = await buildContext(client, config.context);
+  const context = buildContext(config.context, config.credentialIdToAddress);
   const txSubmissionEndpoint = config.txSubmissionEndpoint ?? "/sequencer/txs";
-  return new StandardRollup(
+  const rollup = new StandardRollup(
     {
       ...config,
       client,
@@ -474,9 +581,14 @@ async function createStandardRollup(rollupConfig, typeBuilderOverrides) {
       ...typeBuilderOverrides
     }
   );
+  if (!context.defaultTxDetails.chain_hash_fragment) {
+    await rollup.hydrate();
+  }
+  return rollup;
 }
 
 // src/rollup/solana-signable-rollup.ts
+var import_multisig = require("@sovereign-sdk/multisig");
 var import_signers = require("@sovereign-sdk/signers");
 var import_utils4 = require("@sovereign-sdk/utils");
 var import_bs58 = __toESM(require("bs58"));
@@ -487,7 +599,6 @@ var CHAIN_HASH_SIZE = 32;
 var PUBKEY_SIZE = 32;
 var SIGNATURE_SIZE = 64;
 var MULTISIG_PREAMBLE_FIXED_LENGTH = 53;
-var MAX_MULTISIG_SIGNERS = 21;
 var SIGNING_DOMAIN = new Uint8Array([
   255,
   ...new TextEncoder().encode("solana offchain")
@@ -504,9 +615,9 @@ function compareByteArrays(left, right) {
   return left.length - right.length;
 }
 function createSolanaPreamble(pubkeys, chainHash, messageLength) {
-  if (pubkeys.length < 1 || pubkeys.length > MAX_MULTISIG_SIGNERS) {
+  if (pubkeys.length < 1 || pubkeys.length > import_multisig.MAX_SIGNERS) {
     throw new Error(
-      `Invalid signer count: expected 1-${MAX_MULTISIG_SIGNERS} signers, got ${pubkeys.length}`
+      `Invalid signer count: expected 1-${import_multisig.MAX_SIGNERS} signers, got ${pubkeys.length}`
     );
   }
   const preamble = new Uint8Array(
@@ -552,45 +663,37 @@ var SolanaSignableRollup = class {
   /**
    * Submits serialized data to the Solana endpoint.
    */
-  async submitSerializedMessage(serializedMessage) {
+  async submitSerializedMessage(serializedMessage, options) {
+    const { body: _, query: __, path, ...requestOptions } = options || {};
     return await this.inner.http.post(
-      this.solanaEndpoint,
+      path || this.solanaEndpoint,
       {
         // Match AcceptTx shape used by standard sequencer endpoints.
-        body: { body: import_js_base642.Base64.fromUint8Array(serializedMessage) }
+        body: { body: import_js_base642.Base64.fromUint8Array(serializedMessage) },
+        ...requestOptions
       }
     );
   }
   /**
    * Submits a Solana offchain message to the rollup.
    */
-  async submitSolanaMessage(solanaMessage) {
+  async submitSolanaMessage(solanaMessage, options) {
     const serializedMessage = this.serializeSolanaMessage(solanaMessage);
-    return this.submitSerializedMessage(serializedMessage);
+    return this.submitSerializedMessage(serializedMessage, options);
   }
   /**
    * Submits a Solana spec-compliant message to the rollup.
    */
-  async submitSolanaSpecMessage(solanaMessage) {
+  async submitSolanaSpecMessage(solanaMessage, options) {
     const serializedMessage = this.serializeSolanaSpecMessage(solanaMessage);
-    return this.submitSerializedMessage(serializedMessage);
+    return this.submitSerializedMessage(serializedMessage, options);
   }
   /**
    * Submits a Solana spec-compliant multisig message to the rollup.
    */
-  async submitSolanaSpecMultisigMessage(solanaMessage) {
+  async submitSolanaSpecMultisigMessage(solanaMessage, options) {
     const serializedMessage = this.serializeSolanaSpecMultisigMessage(solanaMessage);
-    return this.submitSerializedMessage(serializedMessage);
-  }
-  /**
-   * Helper to build an unsigned transaction using the standard type builder.
-   */
-  async buildUnsignedTransaction(runtimeCall, overrides) {
-    return this.typeBuilder.unsignedTransaction({
-      runtimeCall,
-      overrides: overrides ?? {},
-      rollup: this.inner
-    });
+    return this.submitSerializedMessage(serializedMessage, options);
   }
   /**
    * Helper to build a transaction result object.
@@ -618,18 +721,15 @@ var SolanaSignableRollup = class {
    * The canonical order is lexicographic by raw pubkey bytes.
    */
   canonicalizeMultisigPubkeys(multisigPubkeys) {
-    if (!multisigPubkeys) {
+    if (multisigPubkeys.length < 1 || multisigPubkeys.length > import_multisig.MAX_SIGNERS) {
       throw new Error(
-        "multisigPubkeys is required for Solana multisig transactions"
-      );
-    }
-    if (multisigPubkeys.length < 2 || multisigPubkeys.length > MAX_MULTISIG_SIGNERS) {
-      throw new Error(
-        `Invalid multisig signer count: expected 2-${MAX_MULTISIG_SIGNERS} signers, got ${multisigPubkeys.length}`
+        `Invalid multisig signer count: expected 1-${import_multisig.MAX_SIGNERS} signers, got ${multisigPubkeys.length}`
       );
     }
     const seenPubkeys = /* @__PURE__ */ new Set();
-    for (const pubkey of multisigPubkeys) {
+    const normalizedPubkeys = multisigPubkeys.map(import_utils4.normalizeHexString);
+    const pubkeyBytes = normalizedPubkeys.map((pubkey) => (0, import_utils4.hexToBytes)(pubkey));
+    for (const pubkey of pubkeyBytes) {
       if (pubkey.length !== PUBKEY_SIZE) {
         throw new Error(
           `Invalid public key length: expected ${PUBKEY_SIZE} bytes, got ${pubkey.length}`
@@ -641,31 +741,36 @@ var SolanaSignableRollup = class {
       }
       seenPubkeys.add(pubkeyHex);
     }
-    return [...multisigPubkeys].sort(compareByteArrays);
+    return pubkeyBytes.sort(compareByteArrays);
   }
   /**
-   * Helper to create and serialize a SolanaOffchainUnsignedTransaction to JSON bytes.
+   * Helper to create and serialize a SolanaOffchainSigningPayloadV0 to JSON bytes.
    */
   async createSolanaJsonBytes(unsignedTx) {
     const serializer = await this.inner.serializer();
     const schema = serializer.schema;
     const chainName = schema.chain_data.chain_name || "";
-    const solanaUnsignedTx = {
+    const solanaSigningPayload = {
       runtime_call: unsignedTx.runtime_call,
       uniqueness: unsignedTx.uniqueness,
       details: unsignedTx.details,
-      chain_name: chainName
+      chain_name: chainName,
+      ...unsignedTx.address_override !== null && unsignedTx.address_override !== void 0 && {
+        address_override: unsignedTx.address_override
+      },
+      version: 0
     };
-    return new TextEncoder().encode(JSON.stringify(solanaUnsignedTx));
+    return new TextEncoder().encode(JSON.stringify(solanaSigningPayload));
   }
   /**
    * Signs an unsigned transaction using Solana offchain simple signing and submits it.
    * Returns the transaction result in the same format as standard rollup.
    */
-  async signWithSolanaSimpleAndSubmit(unsignedTx, signer) {
+  async signWithSolanaSimpleAndSubmit(unsignedTx, signer, options) {
+    const chainHash = await this.inner.chainHash();
+    refreshChainHashFragment(unsignedTx, chainHash);
     const jsonBytes = await this.createSolanaJsonBytes(unsignedTx);
     const pubkey = await signer.publicKey();
-    const chainHash = await this.inner.chainHash();
     const signature = await signer.sign(jsonBytes);
     const solanaMessage = {
       signed_message: jsonBytes,
@@ -673,17 +778,18 @@ var SolanaSignableRollup = class {
       pubkey,
       signature
     };
-    const response = await this.submitSolanaMessage(solanaMessage);
+    const response = await this.submitSolanaMessage(solanaMessage, options);
     return this.buildTransactionResult(response, unsignedTx, pubkey, signature);
   }
   /**
    * Signs an unsigned transaction using Solana spec-compliant signing and submits it.
    * Returns the transaction result in the same format as standard rollup.
    */
-  async signWithSolanaSpecAndSubmit(unsignedTx, signer) {
+  async signWithSolanaSpecAndSubmit(unsignedTx, signer, options) {
+    const chainHash = await this.inner.chainHash();
+    refreshChainHashFragment(unsignedTx, chainHash);
     const jsonBytes = await this.createSolanaJsonBytes(unsignedTx);
     const pubkey = await signer.publicKey();
-    const chainHash = await this.inner.chainHash();
     const preamble = createSolanaPreamble(
       [pubkey],
       chainHash,
@@ -698,7 +804,7 @@ var SolanaSignableRollup = class {
       signed_message_with_preamble: signedMessageWithPreamble,
       signature
     };
-    const response = await this.submitSolanaSpecMessage(solanaMessage);
+    const response = await this.submitSolanaSpecMessage(solanaMessage, options);
     return this.buildTransactionResult(response, unsignedTx, pubkey, signature);
   }
   /**
@@ -722,18 +828,30 @@ var SolanaSignableRollup = class {
           options
         );
       case "solanaSimple": {
-        const unsignedTx = await this.buildUnsignedTransaction(
+        const unsignedTx = await this.inner.buildUnsignedTransaction(
           runtimeCall,
-          params.overrides
+          {
+            overrides: params.overrides
+          }
+        );
+        return this.signWithSolanaSimpleAndSubmit(
+          unsignedTx,
+          params.signer,
+          options
         );
-        return this.signWithSolanaSimpleAndSubmit(unsignedTx, params.signer);
       }
       case "solana": {
-        const unsignedTx = await this.buildUnsignedTransaction(
+        const unsignedTx = await this.inner.buildUnsignedTransaction(
           runtimeCall,
-          params.overrides
+          {
+            overrides: params.overrides
+          }
+        );
+        return this.signWithSolanaSpecAndSubmit(
+          unsignedTx,
+          params.signer,
+          options
         );
-        return this.signWithSolanaSpecAndSubmit(unsignedTx, params.signer);
       }
       default:
         throw new Error(`Unsupported authenticator: ${authenticator}`);
@@ -759,132 +877,134 @@ var SolanaSignableRollup = class {
           options
         );
       case "solanaSimple":
-        return this.signWithSolanaSimpleAndSubmit(unsignedTx, params.signer);
+        return this.signWithSolanaSimpleAndSubmit(
+          unsignedTx,
+          params.signer,
+          options
+        );
       case "solana":
-        return this.signWithSolanaSpecAndSubmit(unsignedTx, params.signer);
+        return this.signWithSolanaSpecAndSubmit(
+          unsignedTx,
+          params.signer,
+          options
+        );
       default:
         throw new Error(`Unsupported authenticator: ${authenticator}`);
     }
   }
+  async buildUnsignedTransaction(runtimeCall, params) {
+    return this.inner.buildUnsignedTransaction(runtimeCall, params);
+  }
   /**
    * Creates V1 JSON bytes for a multisig transaction, including multisig_id and version.
    * The resulting JSON is what each signer signs directly (no discriminator prefix).
    */
-  async createMultisigJsonBytes(unsignedTx, multisigAddress) {
+  async createMultisigJsonBytes(unsignedTx, multisigId) {
     const serializer = await this.inner.serializer();
     const schema = serializer.schema;
     const chainName = schema.chain_data.chain_name || "";
-    const solanaUnsignedTx = {
+    const solanaSigningPayload = {
       runtime_call: unsignedTx.runtime_call,
       uniqueness: unsignedTx.uniqueness,
       details: unsignedTx.details,
       chain_name: chainName,
-      // Hardcoded to base58 encoding, only correct for rollups using Base58Address as their
-      // primary address type. Will be replaced with rollup-aware address formatting once the
-      // SDK supports flexible address encoding (see #2673).
-      multisig_id: import_bs58.default.encode(multisigAddress),
+      multisig_id: multisigId,
+      ...unsignedTx.address_override !== null && unsignedTx.address_override !== void 0 && {
+        address_override: unsignedTx.address_override
+      },
       version: 1
     };
-    return new TextEncoder().encode(JSON.stringify(solanaUnsignedTx));
+    return new TextEncoder().encode(JSON.stringify(solanaSigningPayload));
   }
   /**
-   * Creates the preamble+JSON bytes signed by every signer in a spec-compliant multisig flow.
+   * Formats the multisig credential in the rollup's configured address format.
    */
-  async createSpecCompliantMultisigSignedMessage(unsignedTx, multisigAddress, multisigPubkeys) {
-    const jsonBytes = await this.createMultisigJsonBytes(
-      unsignedTx,
-      multisigAddress
-    );
-    const chainHash = await this.inner.chainHash();
-    const preamble = createSolanaPreamble(
-      multisigPubkeys,
-      chainHash,
-      jsonBytes.length
-    );
-    return this.combinePreambleAndMessage(preamble, jsonBytes);
+  async multisigIdFromMultisig(multisig) {
+    const credentialId = multisig.getMultisigAddress();
+    if (this.inner.context.credentialIdToAddress) {
+      const serializer = await this.inner.serializer();
+      return this.inner.context.credentialIdToAddress(
+        credentialId,
+        serializer.schema
+      );
+    }
+    return import_bs58.default.encode(credentialId);
   }
   /**
-   * Signs an unsigned transaction using Solana offchain simple multisig signing.
+   * Creates multisig state from a finalized transaction envelope.
    */
-  async signForSolanaSimpleMultisig(unsignedTx, signer, multisigAddress, multisigPubkeys) {
-    const pubkey = await signer.publicKey();
-    const signerPubkeyHex = (0, import_utils4.bytesToHex)(pubkey);
-    const multisigPubkeyHexes = multisigPubkeys.map(import_utils4.bytesToHex);
-    if (!multisigPubkeyHexes.includes(signerPubkeyHex)) {
-      throw new Error(
-        `Signer public key ${signerPubkeyHex} is not present in multisigPubkeys`
-      );
-    }
-    const jsonBytes = await this.createMultisigJsonBytes(
-      unsignedTx,
-      multisigAddress
-    );
-    const signature = await signer.sign(jsonBytes);
-    return this.typeBuilder.transaction({
-      unsignedTx,
-      sender: pubkey,
-      signature,
-      rollup: this.inner
+  multisigFromTransaction(tx) {
+    return new import_multisig.Multisig({
+      signatures: tx.signatures,
+      unusedPubKeys: tx.unused_pub_keys,
+      minSigners: tx.min_signers
     });
   }
+  normalizeMultisigTransaction(tx) {
+    return {
+      ...tx,
+      signatures: tx.signatures.map((signature) => ({
+        signature: (0, import_utils4.normalizeHexString)(signature.signature),
+        pub_key: (0, import_utils4.normalizeHexString)(signature.pub_key)
+      })),
+      unused_pub_keys: tx.unused_pub_keys.map(import_utils4.normalizeHexString)
+    };
+  }
   /**
-   * Signs an unsigned transaction using the spec-compliant multisig preamble.
+   * Extracts the V0-shaped unsigned fields from a finalized multisig transaction.
    */
-  async signForSolanaSpecMultisig(unsignedTx, signer, multisigAddress, multisigPubkeys) {
-    const pubkey = await signer.publicKey();
-    const signerPubkeyHex = (0, import_utils4.bytesToHex)(pubkey);
-    const multisigPubkeyHexes = multisigPubkeys.map(import_utils4.bytesToHex);
-    if (!multisigPubkeyHexes.includes(signerPubkeyHex)) {
-      throw new Error(
-        `Signer public key ${signerPubkeyHex} is not present in multisigPubkeys`
-      );
-    }
-    const signedMessageWithPreamble = await this.createSpecCompliantMultisigSignedMessage(
-      unsignedTx,
-      multisigAddress,
-      multisigPubkeys
-    );
-    const signature = await signer.sign(signedMessageWithPreamble);
-    return this.typeBuilder.transaction({
-      unsignedTx,
-      sender: pubkey,
-      signature,
-      rollup: this.inner
-    });
+  unsignedTxFromTransaction(tx) {
+    return {
+      runtime_call: tx.runtime_call,
+      uniqueness: tx.uniqueness,
+      details: tx.details,
+      address_override: tx.address_override
+    };
   }
   /**
-   * Signs an unsigned transaction for use in a Solana offchain multisig.
-   *
-   * `authenticator: "standard"` delegates directly to the wrapped standard rollup.
-   * `authenticator: "solanaSimple"` signs the V1 JSON payload directly.
-   * `authenticator: "solana"` signs the spec-compliant preamble+JSON bytes.
-   * Solana multisig authenticators treat `multisigPubkeys` as an unordered set and
-   * canonicalize it before signing.
+   * Creates the preamble+JSON bytes signed by every signer in a spec-compliant multisig flow.
    */
-  async signTransactionForMultisig(unsignedTx, params) {
-    switch (params.authenticator) {
+  async createSpecCompliantMultisigSignedMessage(unsignedTx, multisig) {
+    const chainHash = await this.inner.chainHash();
+    assertChainHashFragment(unsignedTx, chainHash);
+    const jsonBytes = await this.createMultisigJsonBytes(
+      unsignedTx,
+      await this.multisigIdFromMultisig(multisig)
+    );
+    const preamble = createSolanaPreamble(
+      this.canonicalizeMultisigPubkeys([...multisig.allPubKeys]),
+      chainHash,
+      jsonBytes.length
+    );
+    return this.combinePreambleAndMessage(preamble, jsonBytes);
+  }
+  async multisigSigningBytes(unsignedTx, multisig, authenticator) {
+    switch (authenticator) {
       case "standard":
-        return this.inner.signTransaction(unsignedTx, params.signer);
-      case "solanaSimple":
-        return this.signForSolanaSimpleMultisig(
+        return this.inner.multisigSigningBytes(unsignedTx, multisig);
+      case "solanaSimple": {
+        assertChainHashFragment(unsignedTx, await this.inner.chainHash());
+        return this.createMultisigJsonBytes(
           unsignedTx,
-          params.signer,
-          params.multisigAddress,
-          this.canonicalizeMultisigPubkeys(params.multisigPubkeys)
+          await this.multisigIdFromMultisig(multisig)
         );
+      }
       case "solana":
-        return this.signForSolanaSpecMultisig(
+        return this.createSpecCompliantMultisigSignedMessage(
           unsignedTx,
-          params.signer,
-          params.multisigAddress,
-          this.canonicalizeMultisigPubkeys(params.multisigPubkeys)
+          multisig
         );
     }
+    throw new Error(`Unsupported authenticator: ${authenticator}`);
   }
   /**
-   * Builds a spec-compliant multisig envelope from a V1 transaction and ordered multisig pubkeys.
+   * Builds a spec-compliant multisig envelope from a V1 transaction.
    */
-  buildSpecCompliantMultisigEnvelope(tx, signedMessageWithPreamble, multisigPubkeys) {
+  buildSpecCompliantMultisigEnvelope(tx, signedMessageWithPreamble) {
+    const multisigPubkeys = this.canonicalizeMultisigPubkeys([
+      ...tx.signatures.map((signer) => signer.pub_key),
+      ...tx.unused_pub_keys
+    ]);
     const multisigPubkeyHexes = multisigPubkeys.map(import_utils4.bytesToHex);
     const indexByPubkey = /* @__PURE__ */ new Map();
     multisigPubkeyHexes.forEach((pubkeyHex, index) => {
@@ -894,37 +1014,42 @@ var SolanaSignableRollup = class {
     const signaturesByIndex = /* @__PURE__ */ new Map();
     let signerBitfield = 0;
     for (const signer of tx.signatures) {
-      const signerIndex = indexByPubkey.get(signer.pub_key);
+      const normalizedSignerPubkey = (0, import_utils4.normalizeHexString)(signer.pub_key);
+      const signerIndex = indexByPubkey.get(normalizedSignerPubkey);
       if (signerIndex === void 0) {
         throw new Error(
-          `Signed pubkey ${signer.pub_key} is not present in multisigPubkeys`
+          `Signed pubkey ${normalizedSignerPubkey} is not present in multisigPubkeys`
         );
       }
-      if (accountedPubkeys.has(signer.pub_key)) {
+      if (accountedPubkeys.has(normalizedSignerPubkey)) {
         throw new Error(
-          `Duplicate signed pubkey in multisig transaction: ${signer.pub_key}`
+          `Duplicate signed pubkey in multisig transaction: ${normalizedSignerPubkey}`
         );
       }
-      accountedPubkeys.add(signer.pub_key);
-      signaturesByIndex.set(signerIndex, (0, import_utils4.hexToBytes)(signer.signature));
+      accountedPubkeys.add(normalizedSignerPubkey);
+      signaturesByIndex.set(
+        signerIndex,
+        (0, import_utils4.hexToBytes)((0, import_utils4.normalizeHexString)(signer.signature))
+      );
       signerBitfield = (signerBitfield | 1 << signerIndex) >>> 0;
     }
     for (const unusedPubkey of tx.unused_pub_keys) {
-      if (!indexByPubkey.has(unusedPubkey)) {
+      const normalizedUnusedPubkey = (0, import_utils4.normalizeHexString)(unusedPubkey);
+      if (!indexByPubkey.has(normalizedUnusedPubkey)) {
         throw new Error(
-          `Unused pubkey ${unusedPubkey} is not present in multisigPubkeys`
+          `Unused pubkey ${normalizedUnusedPubkey} is not present in multisigPubkeys`
         );
       }
-      if (accountedPubkeys.has(unusedPubkey)) {
+      if (accountedPubkeys.has(normalizedUnusedPubkey)) {
         throw new Error(
-          `Duplicate pubkey in multisig transaction payload: ${unusedPubkey}`
+          `Duplicate pubkey in multisig transaction payload: ${normalizedUnusedPubkey}`
         );
       }
-      accountedPubkeys.add(unusedPubkey);
+      accountedPubkeys.add(normalizedUnusedPubkey);
     }
     if (accountedPubkeys.size !== multisigPubkeys.length) {
       throw new Error(
-        "multisigPubkeys must contain every signer and unused pubkey exactly once"
+        "Multisig transaction payload must contain every signer exactly once"
       );
     }
     const orderedSignatures = Array.from(signaturesByIndex.entries()).sort(([leftIndex], [rightIndex]) => leftIndex - rightIndex).map(([, signature]) => signature);
@@ -936,72 +1061,100 @@ var SolanaSignableRollup = class {
     };
   }
   /**
-   * Submits a multisig transaction using the Solana offchain simple multisig format.
-   *
-   * Accepts the V1 transaction produced by `MultisigTransaction.asTransaction()`.
-   * `authenticator: "standard"` delegates directly to the wrapped standard rollup.
-   * Solana authenticators rebuild the appropriate Solana multisig envelope and
-   * submit it to the Solana offchain endpoint.
+   * Submits a finalized V1 multisig transaction using a Solana authenticator.
    */
-  async submitMultisigTransaction(multisigTx, params) {
-    const { V1: tx } = multisigTx;
-    const unsignedTx = {
-      runtime_call: tx.runtime_call,
-      uniqueness: tx.uniqueness,
-      details: tx.details
+  async submitMultisigTransactionWithAuthenticator(transaction, authenticator, options) {
+    const finalizedTx = {
+      V1: this.normalizeMultisigTransaction(transaction.V1)
     };
-    switch (params.authenticator) {
-      case "standard":
-        return this.inner.submitTransaction(
-          multisigTx
-        );
+    const multisig = this.multisigFromTransaction(finalizedTx.V1);
+    if (!multisig.isComplete) {
+      throw new Error("Multisig transaction is incomplete");
+    }
+    const unsignedTx = this.unsignedTxFromTransaction(finalizedTx.V1);
+    switch (authenticator) {
       case "solanaSimple": {
-        this.canonicalizeMultisigPubkeys(params.multisigPubkeys);
+        const chainHash = await this.inner.chainHash();
+        assertChainHashFragment(unsignedTx, chainHash);
         const jsonBytes = await this.createMultisigJsonBytes(
           unsignedTx,
-          params.multisigAddress
+          await this.multisigIdFromMultisig(multisig)
         );
         const wireBytes = new Uint8Array(1 + jsonBytes.length);
         wireBytes[0] = MULTISIG_SIMPLE_DISCRIMINATOR;
         wireBytes.set(jsonBytes, 1);
-        const chainHash = await this.inner.chainHash();
         const serialized = this.serializeSolanaMultisigMessage({
           wire_bytes: wireBytes,
           chain_hash: chainHash,
-          signatures: tx.signatures.map((s) => ({
+          signatures: finalizedTx.V1.signatures.map((s) => ({
             signature: (0, import_utils4.hexToBytes)(s.signature),
             pub_key: (0, import_utils4.hexToBytes)(s.pub_key)
           })),
-          unused_pub_keys: tx.unused_pub_keys.map((pk) => (0, import_utils4.hexToBytes)(pk)),
-          min_signers: tx.min_signers
+          unused_pub_keys: finalizedTx.V1.unused_pub_keys.map(
+            (pk) => (0, import_utils4.hexToBytes)(pk)
+          ),
+          min_signers: finalizedTx.V1.min_signers
         });
-        return this.submitSerializedMessage(serialized);
+        return this.submitSerializedMessage(serialized, options);
       }
       case "solana": {
-        const multisigPubkeys = this.canonicalizeMultisigPubkeys(
-          params.multisigPubkeys
-        );
         const signedMessageWithPreamble = await this.createSpecCompliantMultisigSignedMessage(
           unsignedTx,
-          params.multisigAddress,
-          multisigPubkeys
+          multisig
         );
         const message = this.buildSpecCompliantMultisigEnvelope(
-          tx,
-          signedMessageWithPreamble,
-          multisigPubkeys
+          finalizedTx.V1,
+          signedMessageWithPreamble
+        );
+        return this.submitSolanaSpecMultisigMessage(message, options);
+      }
+    }
+  }
+  /**
+   * Submits a finalized V0 transaction using a Solana authenticator.
+   */
+  async submitSingleSignatureTransactionWithAuthenticator(transaction, authenticator, options) {
+    const unsignedTx = {
+      runtime_call: transaction.runtime_call,
+      uniqueness: transaction.uniqueness,
+      details: transaction.details,
+      address_override: transaction.address_override
+    };
+    const pubkey = (0, import_utils4.hexToBytes)((0, import_utils4.normalizeHexString)(transaction.pub_key));
+    const signature = (0, import_utils4.hexToBytes)((0, import_utils4.normalizeHexString)(transaction.signature));
+    const chainHash = await this.inner.chainHash();
+    assertChainHashFragment(unsignedTx, chainHash);
+    switch (authenticator) {
+      case "solanaSimple": {
+        const signedMessage = await this.createSolanaJsonBytes(unsignedTx);
+        const message = {
+          signed_message: signedMessage,
+          chain_hash: chainHash,
+          pubkey,
+          signature
+        };
+        return this.submitSolanaMessage(message, options);
+      }
+      case "solana": {
+        const signedMessage = await this.createSolanaJsonBytes(unsignedTx);
+        const preamble = createSolanaPreamble(
+          [pubkey],
+          chainHash,
+          signedMessage.length
         );
-        return this.submitSolanaSpecMultisigMessage(message);
+        const message = {
+          signed_message_with_preamble: this.combinePreambleAndMessage(
+            preamble,
+            signedMessage
+          ),
+          signature
+        };
+        return this.submitSolanaSpecMessage(message, options);
       }
     }
   }
   /**
    * Submits a transaction with the specified authenticator.
-   *
-   * @param transaction - Either a standard transaction or a Solana message
-   * @param authenticator - The authenticator type to use
-   * @param options - Optional request options
-   * @returns The transaction response
    */
   async submitTransaction(transaction, authenticator, options) {
     switch (authenticator) {
@@ -1010,17 +1163,34 @@ var SolanaSignableRollup = class {
           transaction,
           options
         );
-      case "solanaSimple": {
-        const solanaMessage = transaction;
-        return await this.submitSolanaMessage(solanaMessage);
-      }
-      case "solana": {
-        const solanaMessage = transaction;
-        return await this.submitSolanaSpecMessage(solanaMessage);
-      }
-      default:
-        throw new Error(`Unsupported authenticator: ${authenticator}`);
+      case "solanaSimple":
+        if ("V1" in transaction) {
+          return this.submitMultisigTransactionWithAuthenticator(
+            transaction,
+            "solanaSimple",
+            options
+          );
+        }
+        return this.submitSingleSignatureTransactionWithAuthenticator(
+          transaction.V0,
+          "solanaSimple",
+          options
+        );
+      case "solana":
+        if ("V1" in transaction) {
+          return this.submitMultisigTransactionWithAuthenticator(
+            transaction,
+            "solana",
+            options
+          );
+        }
+        return this.submitSingleSignatureTransactionWithAuthenticator(
+          transaction.V0,
+          "solana",
+          options
+        );
     }
+    throw new Error(`Unsupported authenticator: ${authenticator}`);
   }
   async simulate(runtimeMessage, params) {
     return this.inner.simulate(runtimeMessage, params);
@@ -1028,6 +1198,9 @@ var SolanaSignableRollup = class {
   async dedup(address) {
     return this.inner.dedup(address);
   }
+  async dedupByCredentialId(credentialId) {
+    return this.inner.dedupByCredentialId(credentialId);
+  }
   async serializer() {
     return this.inner.serializer();
   }
@@ -1063,7 +1236,7 @@ var SolanaSignableRollup = class {
     return this.inner.http;
   }
   /**
-   * Helper method to serialize a SolanaOffchainSimpleMessage using borsh encoding.
+   * Helper method to serialize a SolanaOffchainSimpleEnvelope using borsh encoding.
    */
   serializeSolanaMessage(message) {
     if (message.chain_hash.length !== CHAIN_HASH_SIZE) {
@@ -1097,7 +1270,7 @@ var SolanaSignableRollup = class {
     return buffer;
   }
   /**
-   * Helper method to serialize a SolanaOffchainSpecCompliantMessage using borsh encoding.
+   * Helper method to serialize a SolanaOffchainSpecCompliantEnvelope using borsh encoding.
    */
   serializeSolanaSpecMessage(message) {
     if (message.signature.length !== SIGNATURE_SIZE) {
@@ -1117,7 +1290,7 @@ var SolanaSignableRollup = class {
     return buffer;
   }
   /**
-   * Serializes a SolanaOffchainSimpleMultisigMessage using borsh encoding.
+   * Serializes a SolanaOffchainSimpleMultisigEnvelope using borsh encoding.
    * Layout matches the Rust struct:
    *   [u32 LE: wire_bytes.len][wire_bytes]
    *   [32 bytes: chain_hash]
@@ -1178,7 +1351,7 @@ var SolanaSignableRollup = class {
     return buffer;
   }
   /**
-   * Serializes a SolanaOffchainSpecCompliantMultisigMessage using borsh encoding.
+   * Serializes a SolanaOffchainSpecCompliantMultisigEnvelope using borsh encoding.
    * Layout matches the Rust struct:
    *   [u32 LE: signed_message_with_preamble.len][signed_message_with_preamble]
    *   [u32 LE: signatures.len]
@@ -1232,6 +1405,7 @@ var SovereignClient3 = __toESM(require("@sovereign-sdk/client"));
   StandardRollup,
   VersionMismatchError,
   addressFromPublicKey,
+  chainHashFragment,
   createSolanaSignableRollup,
   createStandardRollup,
   standardTypeBuilder