@sovereign-sdk/web3 0.12.2 → 0.12.4

package/dist/index.mjs

@@ -1,55 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
 // src/addresses.ts
 import { ensureBytes } from "@sovereign-sdk/utils";
 import { bech32m } from "bech32";
@@ -101,7 +49,6 @@ function httpToWebSocket(url) {
 }
 var _subscriptions = {};
 function subscribe(url, callback) {
-  var _a;
   const subscription = _subscriptions[url];
   if (!subscription) {
     const websocket = new WebSocket(url, [], { WebSocket: IsoWebSocket });
@@ -111,9 +58,8 @@ function subscribe(url, callback) {
       callbacks: [callback]
     };
     websocket.addEventListener("message", (message) => {
-      var _a2;
       const data = JSON.parse(message.data);
-      const callbacks = (_a2 = _subscriptions[url]) == null ? void 0 : _a2.callbacks;
+      const callbacks = _subscriptions[url]?.callbacks;
       if (callbacks) {
         for (const cb of callbacks) {
           cb(data);
@@ -127,7 +73,7 @@ function subscribe(url, callback) {
   } else {
     subscription.callbacks.push(callback);
   }
-  const callbackIndex = ((_a = _subscriptions[url]) == null ? void 0 : _a.callbacks.length) - 1;
+  const callbackIndex = _subscriptions[url]?.callbacks.length - 1;
   return {
     get url() {
       return url;
@@ -177,12 +123,10 @@ var Rollup = class {
    * @param publicKey - The public key to dedup.
    * TODO: How to add param for generation explicitly
    */
-  dedup(publicKey) {
-    return __async(this, null, function* () {
-      const credentialId = bytesToHex(publicKey);
-      const response = yield this.rollup.addresses.dedup(credentialId);
-      return response;
-    });
+  async dedup(publicKey) {
+    const credentialId = bytesToHex(publicKey);
+    const response = await this.rollup.addresses.dedup(credentialId);
+    return response;
   }
   /**
    * Submits a transaction to the rollup.
@@ -193,30 +137,29 @@ var Rollup = class {
    * @param transaction - The transaction to submit.
    * @param {SovereignClient.RequestOptions} options - The options for the request.
    */
-  submitTransaction(transaction, options) {
-    return __async(this, null, function* () {
-      const serializer = yield this.serializer();
-      const serializedTx = serializer.serializeTx(transaction);
-      const _a = options || {}, { body: _, query: __, path } = _a, requestOptions = __objRest(_a, ["body", "query", "path"]);
-      const txSubmissionEndpoint = path || this._config.txSubmissionEndpoint;
-      return this.http.post(txSubmissionEndpoint, __spreadValues({
-        body: { body: Base64.fromUint8Array(serializedTx) }
-      }, requestOptions)).catch((e) => __async(this, null, function* () {
-        if (isVersionMismatchError(e)) {
-          const oldVersion = bytesToHex(yield this.chainHash());
-          const { schema, chain_hash: newVersion } = yield this.rollup.schema();
-          this._chainHash = hexToBytes(newVersion);
-          this._serializer = this._config.getSerializer(schema);
-          if (oldVersion !== newVersion) {
-            throw new VersionMismatchError(
-              "Schema version mismatch when submitting transaction",
-              newVersion,
-              oldVersion
-            );
-          }
+  async submitTransaction(transaction, options) {
+    const serializer = await this.serializer();
+    const serializedTx = serializer.serializeTx(transaction);
+    const { body: _, query: __, path, ...requestOptions } = options || {};
+    const txSubmissionEndpoint = path || this._config.txSubmissionEndpoint;
+    return this.http.post(txSubmissionEndpoint, {
+      body: { body: Base64.fromUint8Array(serializedTx) },
+      ...requestOptions
+    }).catch(async (e) => {
+      if (isVersionMismatchError(e)) {
+        const oldVersion = bytesToHex(await this.chainHash());
+        const { schema, chain_hash: newVersion } = await this.rollup.schema();
+        this._chainHash = hexToBytes(newVersion);
+        this._serializer = this._config.getSerializer(schema);
+        if (`0x${oldVersion}` !== newVersion) {
+          throw new VersionMismatchError(
+            "Schema version mismatch when submitting transaction",
+            newVersion,
+            oldVersion
+          );
         }
-        throw e;
-      }));
+      }
+      throw e;
     });
   }
   /**
@@ -228,12 +171,10 @@ var Rollup = class {
    * @param {SovereignClient.RequestOptions} options - The options for the request.
    * @param endpoint - Optional endpoint override. If not specified, uses the rollup's configured txSubmissionEndpoint.
    */
-  signAndSubmitTransaction(_0, _1, _2) {
-    return __async(this, arguments, function* (unsignedTx, { signer }, options) {
-      const tx = yield this.signTransaction(unsignedTx, signer);
-      const result = yield this.submitTransaction(tx, options);
-      return { transaction: tx, response: result };
-    });
+  async signAndSubmitTransaction(unsignedTx, { signer }, options) {
+    const tx = await this.signTransaction(unsignedTx, signer);
+    const result = await this.submitTransaction(tx, options);
+    return { transaction: tx, response: result };
   }
   /**
    * Performs a runtime call transaction.
@@ -243,22 +184,20 @@ var Rollup = class {
    * @param {CallParams<S>} params - The params for submitting a runtime call transaction.
    * @param {SovereignClient.RequestOptions} options - The options for the request.
    */
-  call(_0, _1, _2) {
-    return __async(this, arguments, function* (runtimeCall, { signer, overrides }, options) {
-      const context = {
-        runtimeCall,
-        rollup: this,
-        overrides: overrides != null ? overrides : {}
-      };
-      const unsignedTx = yield this._typeBuilder.unsignedTransaction(context);
-      return this.signAndSubmitTransaction(
-        unsignedTx,
-        {
-          signer
-        },
-        options
-      );
-    });
+  async call(runtimeCall, { signer, overrides }, options) {
+    const context = {
+      runtimeCall,
+      rollup: this,
+      overrides: overrides ?? {}
+    };
+    const unsignedTx = await this._typeBuilder.unsignedTransaction(context);
+    return this.signAndSubmitTransaction(
+      unsignedTx,
+      {
+        signer
+      },
+      options
+    );
   }
   /**
    * Prepares a runtime call by creating and signing a transaction without submitting it.
@@ -271,16 +210,14 @@ var Rollup = class {
    * @param params.overrides - Optional overrides for the unsigned transaction.
    * @returns A promise that resolves to the signed transaction.
    */
-  prepareCall(_0, _1) {
-    return __async(this, arguments, function* (runtimeCall, { signer, overrides }) {
-      const context = {
-        runtimeCall,
-        rollup: this,
-        overrides: overrides != null ? overrides : {}
-      };
-      const unsignedTx = yield this._typeBuilder.unsignedTransaction(context);
-      return this.signTransaction(unsignedTx, signer);
-    });
+  async prepareCall(runtimeCall, { signer, overrides }) {
+    const context = {
+      runtimeCall,
+      rollup: this,
+      overrides: overrides ?? {}
+    };
+    const unsignedTx = await this._typeBuilder.unsignedTransaction(context);
+    return this.signTransaction(unsignedTx, signer);
   }
   /**
    * Signs an unsigned transaction using the provided signer.
@@ -291,23 +228,21 @@ var Rollup = class {
    * @param signer - The signer to use for signing the transaction.
    * @returns A promise that resolves to the signed transaction.
    */
-  signTransaction(unsignedTx, signer) {
-    return __async(this, null, function* () {
-      const serializer = yield this.serializer();
-      const serializedUnsignedTx = serializer.serializeUnsignedTx(unsignedTx);
-      const chainHash = yield this.chainHash();
-      const signature = yield signer.sign(
-        new Uint8Array([...serializedUnsignedTx, ...chainHash])
-      );
-      const publicKey = yield signer.publicKey();
-      const context = {
-        unsignedTx,
-        sender: publicKey,
-        signature,
-        rollup: this
-      };
-      return this._typeBuilder.transaction(context);
-    });
+  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 publicKey = await signer.publicKey();
+    const context = {
+      unsignedTx,
+      sender: publicKey,
+      signature,
+      rollup: this
+    };
+    return this._typeBuilder.transaction(context);
   }
   /**
    * Create a subscription to events emitted over websockets by the rollup.
@@ -321,15 +256,13 @@ var Rollup = class {
    * @param timeout - Request timeout in milliseconds.
    * @returns `true` if the rollup is considered healthy otherwise `false`.
    */
-  healthcheck(timeout = 5e3) {
-    return __async(this, null, function* () {
-      try {
-        yield this.http.get("/healthcheck", { timeout, maxRetries: 1 });
-        return true;
-      } catch (e) {
-        return !(e instanceof SovereignClient.APIConnectionError);
-      }
-    });
+  async healthcheck(timeout = 5e3) {
+    try {
+      await this.http.get("/healthcheck", { timeout, maxRetries: 1 });
+      return true;
+    } catch (e) {
+      return !(e instanceof SovereignClient.APIConnectionError);
+    }
   }
   /**
    * A ledger client that can be used to query the ledger.
@@ -361,13 +294,11 @@ var Rollup = class {
    * The serializer for the rollup.
    * Can be used to serialize transactions, runtime calls, etc.
    */
-  serializer() {
-    return __async(this, null, function* () {
-      if (this._serializer) return this._serializer;
-      const { schema } = yield this.rollup.schema();
-      this._serializer = this._config.getSerializer(schema);
-      return this._serializer;
-    });
+  async serializer() {
+    if (this._serializer) return this._serializer;
+    const { schema } = await this.rollup.schema();
+    this._serializer = this._config.getSerializer(schema);
+    return this._serializer;
   }
   /**
    * The context for the rollup.
@@ -375,20 +306,17 @@ var Rollup = class {
   get context() {
     return this._config.context;
   }
-  chainHash() {
-    return __async(this, null, function* () {
-      if (this._chainHash) return this._chainHash;
-      const { chain_hash } = yield this.rollup.schema();
-      this._chainHash = hexToBytes(chain_hash);
-      return this._chainHash;
-    });
+  async chainHash() {
+    if (this._chainHash) return this._chainHash;
+    const { chain_hash } = await this.rollup.schema();
+    this._chainHash = hexToBytes(chain_hash);
+    return this._chainHash;
   }
 };
 function isVersionMismatchError(e) {
-  var _a, _b, _c;
   if (
     // biome-ignore lint/suspicious/noExplicitAny: yolo
-    (_c = (_b = (_a = e.error) == null ? void 0 : _a.details) == null ? void 0 : _b.error) == null ? void 0 : _c.includes("Signature verification failed")
+    e.error?.details?.error?.includes("Signature verification failed")
   ) {
     return true;
   }
@@ -399,42 +327,42 @@ function isVersionMismatchError(e) {
 import SovereignClient2 from "@sovereign-sdk/client";
 import { JsSerializer } from "@sovereign-sdk/serializers";
 import { bytesToHex as bytesToHex2 } from "@sovereign-sdk/utils";
-var useOrFetchUniqueness = (_0) => __async(void 0, [_0], function* ({
+var useOrFetchUniqueness = async ({
   overrides
-}) {
-  if (overrides == null ? void 0 : overrides.uniqueness) {
+}) => {
+  if (overrides?.uniqueness) {
     return overrides.uniqueness;
   }
   return { generation: Date.now() };
-});
+};
 function standardTypeBuilder() {
   return {
-    unsignedTransaction(context) {
-      return __async(this, null, function* () {
-        const { rollup, runtimeCall } = context;
-        const _a2 = context.overrides, { uniqueness: _ } = _a2, overrides = __objRest(_a2, ["uniqueness"]);
-        const uniqueness = yield useOrFetchUniqueness(context);
-        const details = __spreadValues(__spreadValues({}, rollup.context.defaultTxDetails), overrides.details);
-        return {
-          runtime_call: runtimeCall,
-          uniqueness,
-          details
-        };
-      });
+    async unsignedTransaction(context) {
+      const { rollup, runtimeCall } = context;
+      const { uniqueness: _, ...overrides } = context.overrides;
+      const uniqueness = await useOrFetchUniqueness(context);
+      const details = {
+        ...rollup.context.defaultTxDetails,
+        ...overrides.details
+      };
+      return {
+        runtime_call: runtimeCall,
+        uniqueness,
+        details
+      };
     },
-    transaction(_0) {
-      return __async(this, arguments, function* ({
-        sender,
-        signature,
-        unsignedTx
-      }) {
-        return {
-          V0: __spreadValues({
-            pub_key: bytesToHex2(sender),
-            signature: bytesToHex2(signature)
-          }, unsignedTx)
-        };
-      });
+    async transaction({
+      sender,
+      signature,
+      unsignedTx
+    }) {
+      return {
+        V0: {
+          pub_key: bytesToHex2(sender),
+          signature: bytesToHex2(signature),
+          ...unsignedTx
+        }
+      };
     }
   };
 }
@@ -446,13 +374,11 @@ var StandardRollup = class extends Rollup {
    *
    * @param runtimeMessage - The runtime message to call.
    */
-  simulate(_0, _1) {
-    return __async(this, arguments, function* (runtimeMessage, { signer }) {
-      const publicKey = yield signer.publicKey();
-      const sender = bytesToHex2(publicKey);
-      const call = runtimeMessage;
-      return this.rollup.simulate({ sender, call });
-    });
+  async simulate(runtimeMessage, { signer }) {
+    const publicKey = await signer.publicKey();
+    const sender = bytesToHex2(publicKey);
+    const call = runtimeMessage;
+    return this.rollup.simulate({ sender, call });
   }
 };
 var DEFAULT_TX_DETAILS = {
@@ -460,36 +386,38 @@ var DEFAULT_TX_DETAILS = {
   max_fee: "100000000",
   gas_limit: null
 };
-function buildContext(client, context) {
-  return __async(this, null, function* () {
-    const defaultTxDetails = __spreadValues(__spreadValues({}, DEFAULT_TX_DETAILS), context == null ? void 0 : context.defaultTxDetails);
-    if (!defaultTxDetails.chain_id) {
-      const { chain_id } = yield client.rollup.constants();
-      defaultTxDetails.chain_id = chain_id;
-    }
-    return {
-      defaultTxDetails
-    };
-  });
+async function buildContext(client, context) {
+  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
+  };
 }
-function createStandardRollup(rollupConfig, typeBuilderOverrides) {
-  return __async(this, null, function* () {
-    var _a, _b, _c;
-    const config = rollupConfig != null ? rollupConfig : {};
-    const client = (_a = config.client) != null ? _a : new SovereignClient2({ baseURL: config.url });
-    const getSerializer = (_b = config.getSerializer) != null ? _b : (schema) => new JsSerializer(schema);
-    const context = yield buildContext(client, config.context);
-    const txSubmissionEndpoint = (_c = config.txSubmissionEndpoint) != null ? _c : "/sequencer/txs";
-    return new StandardRollup(
-      __spreadProps(__spreadValues({}, config), {
-        client,
-        getSerializer,
-        context,
-        txSubmissionEndpoint
-      }),
-      __spreadValues(__spreadValues({}, standardTypeBuilder()), typeBuilderOverrides)
-    );
-  });
+async function createStandardRollup(rollupConfig, typeBuilderOverrides) {
+  const config = rollupConfig ?? {};
+  const client = config.client ?? new SovereignClient2({ baseURL: config.url });
+  const getSerializer = config.getSerializer ?? ((schema) => new JsSerializer(schema));
+  const context = await buildContext(client, config.context);
+  const txSubmissionEndpoint = config.txSubmissionEndpoint ?? "/sequencer/txs";
+  return new StandardRollup(
+    {
+      ...config,
+      client,
+      getSerializer,
+      context,
+      txSubmissionEndpoint
+    },
+    {
+      ...standardTypeBuilder(),
+      ...typeBuilderOverrides
+    }
+  );
 }
 
 // src/rollup/solana-signable-rollup.ts
@@ -542,120 +470,104 @@ var SolanaSignableRollup = class {
   /**
    * Submits serialized data to the Solana endpoint.
    */
-  submitSerializedMessage(serializedMessage) {
-    return __async(this, null, function* () {
-      return yield this.inner.http.post(
-        this.solanaEndpoint,
-        {
-          body: Base642.fromUint8Array(serializedMessage)
-        }
-      );
-    });
+  async submitSerializedMessage(serializedMessage) {
+    return await this.inner.http.post(
+      this.solanaEndpoint,
+      {
+        body: Base642.fromUint8Array(serializedMessage)
+      }
+    );
   }
   /**
    * Submits a Solana offchain message to the rollup.
    */
-  submitSolanaMessage(solanaMessage) {
-    return __async(this, null, function* () {
-      const serializedMessage = this.serializeSolanaMessage(solanaMessage);
-      return this.submitSerializedMessage(serializedMessage);
-    });
+  async submitSolanaMessage(solanaMessage) {
+    const serializedMessage = this.serializeSolanaMessage(solanaMessage);
+    return this.submitSerializedMessage(serializedMessage);
   }
   /**
    * Submits a Solana spec-compliant message to the rollup.
    */
-  submitSolanaSpecMessage(solanaMessage) {
-    return __async(this, null, function* () {
-      const serializedMessage = this.serializeSolanaSpecMessage(solanaMessage);
-      return this.submitSerializedMessage(serializedMessage);
-    });
+  async submitSolanaSpecMessage(solanaMessage) {
+    const serializedMessage = this.serializeSolanaSpecMessage(solanaMessage);
+    return this.submitSerializedMessage(serializedMessage);
   }
   /**
    * Helper to build an unsigned transaction using the standard type builder.
    */
-  buildUnsignedTransaction(runtimeCall, overrides) {
-    return __async(this, null, function* () {
-      return this.typeBuilder.unsignedTransaction({
-        runtimeCall,
-        overrides: overrides != null ? overrides : {},
-        rollup: this.inner
-      });
+  async buildUnsignedTransaction(runtimeCall, overrides) {
+    return this.typeBuilder.unsignedTransaction({
+      runtimeCall,
+      overrides: overrides ?? {},
+      rollup: this.inner
     });
   }
   /**
    * Helper to build a transaction result object.
    */
-  buildTransactionResult(response, unsignedTx, pubkey, signature) {
-    return __async(this, null, function* () {
-      const transaction = yield this.typeBuilder.transaction({
-        unsignedTx,
-        sender: pubkey,
-        signature,
-        rollup: this.inner
-      });
-      return { response, transaction };
+  async buildTransactionResult(response, unsignedTx, pubkey, signature) {
+    const transaction = await this.typeBuilder.transaction({
+      unsignedTx,
+      sender: pubkey,
+      signature,
+      rollup: this.inner
     });
+    return { response, transaction };
   }
   /**
    * Helper to create and serialize a SolanaOffchainUnsignedTransaction to JSON bytes.
    */
-  createSolanaJsonBytes(unsignedTx) {
-    return __async(this, null, function* () {
-      const serializer = yield this.inner.serializer();
-      const schema = serializer.schema;
-      const chainName = schema.chain_name || "";
-      const solanaUnsignedTx = {
-        runtime_call: unsignedTx.runtime_call,
-        uniqueness: unsignedTx.uniqueness,
-        details: unsignedTx.details,
-        chain_name: chainName
-      };
-      return new TextEncoder().encode(JSON.stringify(solanaUnsignedTx));
-    });
+  async createSolanaJsonBytes(unsignedTx) {
+    const serializer = await this.inner.serializer();
+    const schema = serializer.schema;
+    const chainName = schema.chain_name || "";
+    const solanaUnsignedTx = {
+      runtime_call: unsignedTx.runtime_call,
+      uniqueness: unsignedTx.uniqueness,
+      details: unsignedTx.details,
+      chain_name: chainName
+    };
+    return new TextEncoder().encode(JSON.stringify(solanaUnsignedTx));
   }
   /**
    * Signs an unsigned transaction using Solana offchain simple signing and submits it.
    * Returns the transaction result in the same format as standard rollup.
    */
-  signWithSolanaSimpleAndSubmit(unsignedTx, signer) {
-    return __async(this, null, function* () {
-      const jsonBytes = yield this.createSolanaJsonBytes(unsignedTx);
-      const pubkey = yield signer.publicKey();
-      const chainHash = yield this.inner.chainHash();
-      const signature = yield signer.sign(jsonBytes);
-      const solanaMessage = {
-        signed_message: jsonBytes,
-        chain_hash: chainHash,
-        pubkey,
-        signature
-      };
-      const response = yield this.submitSolanaMessage(solanaMessage);
-      return this.buildTransactionResult(response, unsignedTx, pubkey, signature);
-    });
+  async signWithSolanaSimpleAndSubmit(unsignedTx, signer) {
+    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,
+      chain_hash: chainHash,
+      pubkey,
+      signature
+    };
+    const response = await this.submitSolanaMessage(solanaMessage);
+    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.
    */
-  signWithSolanaSpecAndSubmit(unsignedTx, signer) {
-    return __async(this, null, function* () {
-      const jsonBytes = yield this.createSolanaJsonBytes(unsignedTx);
-      const pubkey = yield signer.publicKey();
-      const chainHash = yield this.inner.chainHash();
-      const preamble = createSolanaPreamble(pubkey, chainHash, jsonBytes.length);
-      const signedMessageWithPreamble = new Uint8Array(
-        preamble.length + jsonBytes.length
-      );
-      signedMessageWithPreamble.set(preamble, 0);
-      signedMessageWithPreamble.set(jsonBytes, preamble.length);
-      const signature = yield signer.sign(signedMessageWithPreamble);
-      const solanaMessage = {
-        signed_message_with_preamble: signedMessageWithPreamble,
-        signature
-      };
-      const response = yield this.submitSolanaSpecMessage(solanaMessage);
-      return this.buildTransactionResult(response, unsignedTx, pubkey, signature);
-    });
+  async signWithSolanaSpecAndSubmit(unsignedTx, signer) {
+    const jsonBytes = await this.createSolanaJsonBytes(unsignedTx);
+    const pubkey = await signer.publicKey();
+    const chainHash = await this.inner.chainHash();
+    const preamble = createSolanaPreamble(pubkey, chainHash, jsonBytes.length);
+    const signedMessageWithPreamble = new Uint8Array(
+      preamble.length + jsonBytes.length
+    );
+    signedMessageWithPreamble.set(preamble, 0);
+    signedMessageWithPreamble.set(jsonBytes, preamble.length);
+    const signature = await signer.sign(signedMessageWithPreamble);
+    const solanaMessage = {
+      signed_message_with_preamble: signedMessageWithPreamble,
+      signature
+    };
+    const response = await this.submitSolanaSpecMessage(solanaMessage);
+    return this.buildTransactionResult(response, unsignedTx, pubkey, signature);
   }
   /**
    * Performs a runtime call transaction with the specified authenticator.
@@ -665,37 +577,35 @@ var SolanaSignableRollup = class {
    * @param options - Optional request options
    * @returns The transaction result including hash and transaction object
    */
-  call(runtimeCall, params, options) {
-    return __async(this, null, function* () {
-      const authenticator = params.authenticator === "solanaAuto" ? this.getAutoAuthenticator(params.signer) : params.authenticator;
-      switch (authenticator) {
-        case "standard":
-          return this.inner.call(
-            runtimeCall,
-            {
-              signer: params.signer,
-              overrides: params.overrides
-            },
-            options
-          );
-        case "solanaSimple": {
-          const unsignedTx = yield this.buildUnsignedTransaction(
-            runtimeCall,
-            params.overrides
-          );
-          return this.signWithSolanaSimpleAndSubmit(unsignedTx, params.signer);
-        }
-        case "solana": {
-          const unsignedTx = yield this.buildUnsignedTransaction(
-            runtimeCall,
-            params.overrides
-          );
-          return this.signWithSolanaSpecAndSubmit(unsignedTx, params.signer);
-        }
-        default:
-          throw new Error(`Unsupported authenticator: ${authenticator}`);
+  async call(runtimeCall, params, options) {
+    const authenticator = params.authenticator === "solanaAuto" ? this.getAutoAuthenticator(params.signer) : params.authenticator;
+    switch (authenticator) {
+      case "standard":
+        return this.inner.call(
+          runtimeCall,
+          {
+            signer: params.signer,
+            overrides: params.overrides
+          },
+          options
+        );
+      case "solanaSimple": {
+        const unsignedTx = await this.buildUnsignedTransaction(
+          runtimeCall,
+          params.overrides
+        );
+        return this.signWithSolanaSimpleAndSubmit(unsignedTx, params.signer);
       }
-    });
+      case "solana": {
+        const unsignedTx = await this.buildUnsignedTransaction(
+          runtimeCall,
+          params.overrides
+        );
+        return this.signWithSolanaSpecAndSubmit(unsignedTx, params.signer);
+      }
+      default:
+        throw new Error(`Unsupported authenticator: ${authenticator}`);
+    }
   }
   /**
    * Signs and submits a transaction with the specified authenticator.
@@ -705,26 +615,24 @@ var SolanaSignableRollup = class {
    * @param options - Optional request options
    * @returns The transaction result
    */
-  signAndSubmitTransaction(unsignedTx, params, options) {
-    return __async(this, null, function* () {
-      const authenticator = params.authenticator === "solanaAuto" ? this.getAutoAuthenticator(params.signer) : params.authenticator;
-      switch (authenticator) {
-        case "standard":
-          return this.inner.signAndSubmitTransaction(
-            unsignedTx,
-            {
-              signer: params.signer
-            },
-            options
-          );
-        case "solanaSimple":
-          return this.signWithSolanaSimpleAndSubmit(unsignedTx, params.signer);
-        case "solana":
-          return this.signWithSolanaSpecAndSubmit(unsignedTx, params.signer);
-        default:
-          throw new Error(`Unsupported authenticator: ${authenticator}`);
-      }
-    });
+  async signAndSubmitTransaction(unsignedTx, params, options) {
+    const authenticator = params.authenticator === "solanaAuto" ? this.getAutoAuthenticator(params.signer) : params.authenticator;
+    switch (authenticator) {
+      case "standard":
+        return this.inner.signAndSubmitTransaction(
+          unsignedTx,
+          {
+            signer: params.signer
+          },
+          options
+        );
+      case "solanaSimple":
+        return this.signWithSolanaSimpleAndSubmit(unsignedTx, params.signer);
+      case "solana":
+        return this.signWithSolanaSpecAndSubmit(unsignedTx, params.signer);
+      default:
+        throw new Error(`Unsupported authenticator: ${authenticator}`);
+    }
   }
   /**
    * Submits a transaction with the specified authenticator.
@@ -734,51 +642,39 @@ var SolanaSignableRollup = class {
    * @param options - Optional request options
    * @returns The transaction response
    */
-  submitTransaction(transaction, authenticator, options) {
-    return __async(this, null, function* () {
-      switch (authenticator) {
-        case "standard":
-          return this.inner.submitTransaction(
-            transaction,
-            options
-          );
-        case "solanaSimple": {
-          const solanaMessage = transaction;
-          return yield this.submitSolanaMessage(solanaMessage);
-        }
-        case "solana": {
-          const solanaMessage = transaction;
-          return yield this.submitSolanaSpecMessage(solanaMessage);
-        }
-        default:
-          throw new Error(`Unsupported authenticator: ${authenticator}`);
+  async submitTransaction(transaction, authenticator, options) {
+    switch (authenticator) {
+      case "standard":
+        return this.inner.submitTransaction(
+          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}`);
+    }
   }
-  simulate(runtimeMessage, params) {
-    return __async(this, null, function* () {
-      return this.inner.simulate(runtimeMessage, params);
-    });
+  async simulate(runtimeMessage, params) {
+    return this.inner.simulate(runtimeMessage, params);
   }
-  dedup(address) {
-    return __async(this, null, function* () {
-      return this.inner.dedup(address);
-    });
+  async dedup(address) {
+    return this.inner.dedup(address);
   }
-  serializer() {
-    return __async(this, null, function* () {
-      return this.inner.serializer();
-    });
+  async serializer() {
+    return this.inner.serializer();
   }
-  chainHash() {
-    return __async(this, null, function* () {
-      return this.inner.chainHash();
-    });
+  async chainHash() {
+    return this.inner.chainHash();
   }
-  healthcheck(timeout) {
-    return __async(this, null, function* () {
-      return this.inner.healthcheck(timeout);
-    });
+  async healthcheck(timeout) {
+    return this.inner.healthcheck(timeout);
   }
   subscribe(type, callback) {
     return this.inner.subscribe(type, callback);
@@ -853,11 +749,9 @@ var SolanaSignableRollup = class {
     return buffer;
   }
 };
-function createSolanaSignableRollup(rollupConfig, solanaEndpoint = "/sequencer/accept-solana-offchain-tx") {
-  return __async(this, null, function* () {
-    const standardRollup = yield createStandardRollup(rollupConfig);
-    return new SolanaSignableRollup(standardRollup, solanaEndpoint);
-  });
+async function createSolanaSignableRollup(rollupConfig, solanaEndpoint = "/sequencer/accept-solana-offchain-tx") {
+  const standardRollup = await createStandardRollup(rollupConfig);
+  return new SolanaSignableRollup(standardRollup, solanaEndpoint);
 }
 
 // src/index.ts