@lukso/transaction-decoder 1.0.1-dev.0f1bea5

package/dist/chunk-GXZOF3QY.js

@@ -0,0 +1,839 @@
+import {
+  __name,
+  collectDataKeys,
+  decodeTransaction,
+  isAsyncOperationEnabled,
+  pluginRegistry
+} from "./chunk-XVHJWV5U.js";
+
+// src/core/dataModel.ts
+import { batch, effect, signal } from "@preact/signals-core";
+import { hexToBigInt, isHex, size, slice } from "viem";
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object" || Object.isFrozen(obj)) {
+    return obj;
+  }
+  Object.freeze(obj);
+  for (const prop of Object.getOwnPropertyNames(obj)) {
+    const value = obj[prop];
+    if (value !== null && typeof value === "object") {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+}
+__name(deepFreeze, "deepFreeze");
+var DataModel = class {
+  static {
+    __name(this, "DataModel");
+  }
+  // Nested map structure: Address -> (TokenId | null) -> Signal
+  dataSignals = /* @__PURE__ */ new Map();
+  // Transaction signals: Hash -> (DecoderIndex | null) -> Signal
+  transactionSignals = /* @__PURE__ */ new Map();
+  // Keep track of unique transaction hashes in order
+  transactionOrder = [];
+  options;
+  // Track pending resolved data updates
+  pendingResolvedUpdate = false;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Extract a 20-byte address from a potentially 32-byte hex value
+   * If the input is 32 bytes, validates it's zero-padded and takes the rightmost 20 bytes
+   * If the input is 20 bytes, returns it as-is
+   */
+  extractAddress(hex) {
+    if (!isHex(hex)) {
+      throw new Error(`Invalid hex value: ${hex}`);
+    }
+    const bytes = size(hex);
+    if (bytes === 32) {
+      const first12Bytes = slice(hex, 0, 12);
+      if (hexToBigInt(first12Bytes) !== 0n) {
+        throw new Error(
+          `Invalid 32-byte address: first 12 bytes must be zero for a padded address, got ${first12Bytes}`
+        );
+      }
+      return slice(hex, 12, 32);
+    }
+    if (bytes === 20) {
+      return hex;
+    }
+    throw new Error(`Invalid address length: ${bytes} bytes`);
+  }
+  /**
+   * Get or create a signal for a specific key
+   */
+  getOrCreateSignal(key) {
+    let sig = this.dataSignals.get(key);
+    if (!sig) {
+      sig = signal({
+        loading: false,
+        data: void 0,
+        error: void 0,
+        lastUpdated: void 0
+      });
+      this.dataSignals.set(key, sig);
+      if (this.options.onMissingKeys) {
+        setTimeout(() => {
+          const missing = this.getMissingKeys();
+          if (missing.length > 0) {
+            this.options.onMissingKeys?.(missing);
+          }
+        }, 0);
+      }
+    }
+    return sig;
+  }
+  /**
+   * Extract transaction key from transaction JSON
+   */
+  getTransactionKey(transaction) {
+    if (!transaction || typeof transaction !== "object") {
+      throw new Error("Transaction must be an object");
+    }
+    const tx = transaction;
+    if (!tx.hash && !tx.transactionHash) {
+      throw new Error("Transaction must have hash or transactionHash");
+    }
+    return {
+      hash: tx.hash || tx.transactionHash,
+      decoderIndex: tx.decoderIndex ? tx.decoderIndex : void 0
+    };
+  }
+  /**
+   * Get or create the inner map for a transaction hash
+   */
+  getOrCreateTransactionMap(hash) {
+    const normalizedHash = hash.toLowerCase();
+    let map = this.transactionSignals.get(normalizedHash);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.transactionSignals.set(normalizedHash, map);
+    }
+    return map;
+  }
+  /**
+   * Add one or more transactions to the model
+   * Collects all addresses from all transactions and marks them as loading
+   */
+  addTransactions(jsonTransactions) {
+    const transactions = Array.isArray(jsonTransactions) ? jsonTransactions : [jsonTransactions];
+    const isSingle = !Array.isArray(jsonTransactions);
+    const allAddresses = /* @__PURE__ */ new Set();
+    const transactionAddresses = [];
+    for (const tx of transactions) {
+      const addresses = collectDataKeys(tx);
+      transactionAddresses.push(addresses);
+      for (const addr of addresses) {
+        allAddresses.add(addr);
+      }
+    }
+    const uniqueAddresses = Array.from(allAddresses);
+    if (uniqueAddresses.length > 0) {
+      this.setLoading(uniqueAddresses);
+    }
+    const results = transactions.map((tx, index) => {
+      const key = this.getTransactionKey(tx);
+      const normalizedHash = key.hash.toLowerCase();
+      const decoderIndex = key.decoderIndex || null;
+      const isNewHash = !this.transactionSignals.has(normalizedHash);
+      const txMap = this.getOrCreateTransactionMap(normalizedHash);
+      if (txMap.has(decoderIndex)) {
+        throw new Error(
+          `Transaction already exists: ${normalizedHash}:${decoderIndex || 0}`
+        );
+      }
+      const frozenData = deepFreeze(
+        structuredClone(tx)
+      );
+      const sig = signal({
+        data: frozenData,
+        loading: false,
+        addresses: Object.freeze([...transactionAddresses[index]]),
+        error: void 0,
+        lastUpdated: Date.now(),
+        resolvedData: frozenData,
+        // Start with the same frozen data
+        addressesResolved: false
+      });
+      txMap.set(decoderIndex, sig);
+      if (isNewHash) {
+        this.transactionOrder.push(normalizedHash);
+      }
+      if (this.options.onNewTransaction) {
+        this.options.onNewTransaction(tx);
+      }
+      return sig;
+    });
+    return isSingle ? results[0] : results;
+  }
+  /**
+   * Get an existing transaction signal (returns undefined if not found)
+   */
+  getTransaction(jsonTransaction) {
+    const key = this.getTransactionKey(jsonTransaction);
+    const normalizedHash = key.hash.toLowerCase();
+    const decoderIndex = key.decoderIndex || null;
+    const txMap = this.transactionSignals.get(normalizedHash);
+    if (!txMap) {
+      return void 0;
+    }
+    return txMap.get(decoderIndex);
+  }
+  /**
+   * Get transaction by hash and decoder index
+   */
+  getTransactionByKey(hash, decoderIndex) {
+    const normalizedHash = hash.toLowerCase();
+    const txMap = this.transactionSignals.get(normalizedHash);
+    if (!txMap) {
+      return void 0;
+    }
+    return txMap.get(decoderIndex || null);
+  }
+  /**
+   * Update a transaction's data and re-collect addresses
+   * Useful after async decoding completes
+   */
+  updateTransactionData(hash, newData, decoderIndex) {
+    const normalizedHash = hash.toLowerCase();
+    const txMap = this.transactionSignals.get(normalizedHash);
+    if (!txMap) return;
+    const sig = txMap.get(decoderIndex ?? null);
+    if (!sig) return;
+    const newAddresses = collectDataKeys(newData, true, [
+      ...sig.value.addresses
+    ]);
+    const frozenData = deepFreeze(structuredClone(newData));
+    sig.value = {
+      ...sig.value,
+      data: frozenData,
+      addresses: Object.freeze([...newAddresses]),
+      lastUpdated: Date.now(),
+      // Start with the current data, will be enhanced when addresses load
+      resolvedData: frozenData,
+      addressesResolved: false
+    };
+    this.setLoading(newAddresses);
+    queueMicrotask(() => {
+      this.updateResolvedTransactionData();
+    });
+  }
+  /**
+   * Get all decoded transactions for a hash by index (insertion order)
+   */
+  getTransactionsByIndex(index) {
+    if (index < 0 || index >= this.transactionOrder.length) {
+      return void 0;
+    }
+    const hash = this.transactionOrder[index];
+    return this.transactionSignals.get(hash);
+  }
+  /**
+   * Get transaction hash by index
+   */
+  getTransactionHashByIndex(index) {
+    return this.transactionOrder[index];
+  }
+  /**
+   * Get number of unique transaction hashes
+   */
+  getTransactionCount() {
+    return this.transactionOrder.length;
+  }
+  /**
+   * Get number of decoded transactions for a specific hash
+   */
+  getDecodedCount(hash) {
+    const normalizedHash = hash.toLowerCase();
+    const txMap = this.transactionSignals.get(normalizedHash);
+    return txMap ? txMap.size : 0;
+  }
+  /**
+   * Get all decoded transactions for a specific hash
+   */
+  getDecodedTransactions(hash) {
+    const normalizedHash = hash.toLowerCase();
+    const txMap = this.transactionSignals.get(normalizedHash);
+    return txMap ? Array.from(txMap.values()) : [];
+  }
+  /**
+   * Get address signal (alias for getSignal for clearer API)
+   */
+  getAddress(address) {
+    return this.getSignal(address);
+  }
+  /**
+   * Inject data into the model
+   * Can be called multiple times to progressively add/update data
+   */
+  injectData(dataList) {
+    batch(() => {
+      for (const data of dataList) {
+        const key = data.tokenId ? `${data.address}:${data.tokenId}` : data.address;
+        const sig = this.getOrCreateSignal(key);
+        sig.value = {
+          loading: false,
+          data: deepFreeze(structuredClone(data)),
+          error: void 0,
+          lastUpdated: Date.now()
+        };
+      }
+    });
+    this.updateResolvedTransactionData();
+  }
+  /**
+   * Update a single item
+   */
+  updateData(data) {
+    const key = data.tokenId ? `${data.address}:${data.tokenId}` : data.address;
+    const sig = this.getOrCreateSignal(key);
+    sig.value = {
+      loading: false,
+      data: deepFreeze(structuredClone(data)),
+      error: void 0,
+      lastUpdated: Date.now()
+    };
+    if (!this.pendingResolvedUpdate) {
+      this.pendingResolvedUpdate = true;
+      queueMicrotask(() => {
+        this.pendingResolvedUpdate = false;
+        this.updateResolvedTransactionData();
+      });
+    }
+  }
+  /**
+   * Mark keys as loading
+   */
+  setLoading(keys) {
+    batch(() => {
+      for (const key of keys) {
+        const sig = this.getOrCreateSignal(key);
+        sig.value = { ...sig.value, loading: true };
+      }
+    });
+  }
+  /**
+   * Mark a key as errored
+   */
+  setError(key, error) {
+    const sig = this.getOrCreateSignal(key);
+    sig.value = {
+      loading: false,
+      data: void 0,
+      error,
+      lastUpdated: Date.now()
+    };
+  }
+  /**
+   * Get signal for a key (creates one if doesn't exist)
+   */
+  getSignal(key) {
+    return this.getOrCreateSignal(key);
+  }
+  /**
+   * Subscribe to key updates
+   */
+  subscribe(key, callback) {
+    const sig = this.getSignal(key);
+    return effect(() => callback(sig.value));
+  }
+  /**
+   * Get current state of a key
+   */
+  getState(key) {
+    return this.getSignal(key).value;
+  }
+  /**
+   * Get all keys that have no data
+   */
+  getMissingKeys() {
+    const missingKeys = [];
+    for (const [key] of this.dataSignals) {
+      missingKeys.push(key);
+    }
+    return missingKeys;
+  }
+  /**
+   * Get all keys currently loading
+   */
+  getLoadingKeys() {
+    const loadingKeys = [];
+    for (const [key, sig] of this.dataSignals) {
+      if (sig.value.loading) {
+        loadingKeys.push(key);
+      }
+    }
+    return loadingKeys;
+  }
+  /**
+   * Check if we have data for a key
+   */
+  hasData(key) {
+    const sig = this.dataSignals.get(key);
+    return sig ? sig.value.data !== void 0 : false;
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    batch(() => {
+      for (const sig of this.dataSignals.values()) {
+        sig.value = {
+          loading: false,
+          data: void 0,
+          error: void 0,
+          lastUpdated: void 0
+        };
+      }
+      for (const txMap of this.transactionSignals.values()) {
+        for (const sig of txMap.values()) {
+          sig.value = {
+            ...sig.value,
+            loading: false,
+            error: void 0
+          };
+        }
+      }
+    });
+  }
+  /**
+   * Remove specific keys from cache
+   */
+  remove(keys) {
+    for (const key of keys) {
+      this.dataSignals.delete(key);
+    }
+  }
+  /**
+   * Get all cached keys
+   */
+  getAllKeys() {
+    const keys = [];
+    for (const [key] of this.dataSignals) {
+      keys.push(key);
+    }
+    return Object.freeze(keys);
+  }
+  /**
+   * Get all data as a plain object (for debugging/serialization)
+   */
+  getAllData() {
+    const result = {};
+    for (const [key, sig] of this.dataSignals) {
+      result[key] = sig.value;
+    }
+    return Object.freeze(result);
+  }
+  /**
+   * Get all transaction data (for debugging)
+   */
+  getAllTransactions() {
+    const result = {};
+    for (const [hash, txMap] of this.transactionSignals) {
+      for (const [decoderIndex, sig] of txMap) {
+        const key = decoderIndex === null ? hash : `${hash}:${decoderIndex}`;
+        result[key] = sig.value;
+      }
+    }
+    return Object.freeze(result);
+  }
+  /**
+   * Get all transactions in order (returns all decoded transactions grouped by hash)
+   */
+  getTransactionsInOrder() {
+    const result = [];
+    for (const hash of this.transactionOrder) {
+      const txMap = this.transactionSignals.get(hash);
+      if (txMap) {
+        result.push({
+          hash,
+          transactions: Array.from(txMap.values())
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a resolved version of transaction data with all addresses populated
+   */
+  createResolvedTransactionData(transactionData, addresses) {
+    const resolved = structuredClone(transactionData);
+    const addressMap = /* @__PURE__ */ new Map();
+    for (const key of addresses) {
+      const addressData = this.getData(key);
+      if (addressData) {
+        addressMap.set(key.toLowerCase(), addressData);
+      }
+    }
+    this.replaceAddressesWithPaths(resolved, addressMap);
+    return deepFreeze(resolved);
+  }
+  /**
+   * Replace addresses using path information (similar to collectAddressesWithPaths)
+   */
+  replaceAddressesWithPaths(data, addressMap) {
+    function traverse(obj, path = [], parent) {
+      if (typeof obj === "string" && obj.startsWith("0x")) {
+        const isPaddedAddress = /^0x0*([a-fA-F0-9]{40})$/.test(obj);
+        if (isPaddedAddress || isHex(obj) && size(obj) === 20) {
+          const address = isPaddedAddress ? obj.replace(/^0x0*([a-fA-F0-9]{40})$/, "0x$1") : obj;
+          if (address.slice(2).split("").filter((c) => c === "0").length > 10) {
+            return;
+          }
+          const currentKey = path[path.length - 1];
+          const tokenId = parent && !Array.isArray(parent) && "tokenId" in parent && parent.tokenId ? parent.tokenId : void 0;
+          let addressData;
+          if (tokenId) {
+            const compositeKey = `${address.toLowerCase()}_${tokenId.toLowerCase()}`;
+            addressData = addressMap.get(compositeKey);
+          } else {
+            addressData = addressMap.get(address.toLowerCase());
+          }
+          if (addressData && parent) {
+            if (Array.isArray(parent) && typeof currentKey === "number") {
+              parent[currentKey] = addressData;
+            } else if (!Array.isArray(parent) && typeof currentKey === "string") {
+              parent[currentKey] = addressData;
+            }
+          }
+        }
+        return;
+      }
+      if (!obj || typeof obj !== "object") return;
+      if (Array.isArray(obj)) {
+        for (let index = 0; index < obj.length; index++) {
+          traverse(obj[index], path.concat([index]), obj);
+        }
+      } else {
+        const record = obj;
+        for (const [key, value] of Object.entries(record)) {
+          traverse(value, path.concat([key]), record);
+        }
+      }
+    }
+    __name(traverse, "traverse");
+    traverse(data);
+  }
+  /**
+   * Update resolved transaction data for all transactions where addresses are loaded
+   */
+  updateResolvedTransactionData() {
+    for (const [_hash, txMap] of this.transactionSignals) {
+      for (const [_decoderIndex, signal3] of txMap) {
+        const currentState = signal3.value;
+        if (currentState.addressesResolved || currentState.addresses.length === 0) {
+          continue;
+        }
+        let allAddressesLoaded = true;
+        for (const addressKey of currentState.addresses) {
+          const addressState = this.getState(addressKey);
+          if (addressState.loading || !addressState.data) {
+            allAddressesLoaded = false;
+            break;
+          }
+        }
+        if (allAddressesLoaded) {
+          const resolvedData = this.createResolvedTransactionData(
+            currentState.data,
+            currentState.addresses
+          );
+          signal3.value = {
+            ...currentState,
+            resolvedData,
+            addressesResolved: true,
+            lastUpdated: Date.now()
+          };
+        }
+      }
+    }
+  }
+  /**
+   * Get data by key - convenience method that handles both 20 and 32 byte addresses
+   */
+  getData(key) {
+    return this.getState(key).data;
+  }
+  /**
+   * Check if a key is loading
+   */
+  isLoading(key) {
+    return this.getState(key).loading;
+  }
+  /**
+   * Get error for a key
+   */
+  getError(key) {
+    return this.getState(key).error;
+  }
+};
+function createConsumerProxy(model) {
+  const consumerMethods = [
+    // Transaction read methods
+    "getTransaction",
+    "getTransactionByKey",
+    "getTransactionsByIndex",
+    "getTransactionHashByIndex",
+    "getTransactionCount",
+    "getDecodedCount",
+    "getDecodedTransactions",
+    "getTransactionsInOrder",
+    // Address read methods
+    "getAddress",
+    "getSignal",
+    "subscribe",
+    "getState",
+    "hasData",
+    "getData",
+    "isLoading",
+    "getError",
+    // Collection read methods
+    "getAllKeys",
+    "getAllData",
+    "getAllTransactions"
+  ];
+  const proxy = new Proxy(model, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && consumerMethods.includes(prop)) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      return void 0;
+    },
+    set() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    defineProperty() {
+      return false;
+    },
+    setPrototypeOf() {
+      return false;
+    }
+  });
+  return proxy;
+}
+__name(createConsumerProxy, "createConsumerProxy");
+function createDataModel(options) {
+  const model = new DataModel(options);
+  Object.freeze(DataModel.prototype);
+  Object.freeze(DataModel);
+  return model;
+}
+__name(createDataModel, "createDataModel");
+
+// src/core/instance.ts
+var dataModelInstance = new DataModel();
+Object.freeze(DataModel.prototype);
+Object.freeze(DataModel);
+var dataModel = dataModelInstance;
+var consumerModel = createConsumerProxy(dataModelInstance);
+function createGlobalInstance() {
+  if (typeof window !== "undefined") {
+    const consumerProxy = createConsumerProxy(dataModelInstance);
+    Object.defineProperty(window, "TransactionDecoder", {
+      value: consumerProxy,
+      writable: false,
+      configurable: false,
+      enumerable: true
+    });
+  }
+}
+__name(createGlobalInstance, "createGlobalInstance");
+
+// src/decoder/decodeTransaction.ts
+import { signal as signal2 } from "@preact/signals-core";
+
+// src/shared/constants.ts
+var ERROR_CODES = {
+  INVALID_TRANSACTION: "INVALID_TRANSACTION",
+  DECODING_FAILED: "DECODING_FAILED",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  RATE_LIMIT: "RATE_LIMIT",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  NOT_FOUND: "NOT_FOUND"
+};
+
+// src/decoder/decodeTransaction.ts
+async function decodeTransaction2(transaction, options) {
+  const isBatch = Array.isArray(transaction);
+  const transactions = isBatch ? transaction : [transaction];
+  const results = await decodeTransactionBatch(transactions, options);
+  if (isBatch) {
+    return results;
+  }
+  return results[0];
+}
+__name(decodeTransaction2, "decodeTransaction");
+async function decodeTransactionBatch(transactions, options) {
+  const overridePluginNames = options.plugins?.map((p) => p.name).filter((name) => typeof name === "string") || [];
+  const overrideSchemaNames = options.schemaPlugins?.map((p) => p.name).filter((name) => typeof name === "string") || [];
+  const registeredPlugins = await pluginRegistry.getAll({
+    excludeNames: overridePluginNames
+  });
+  const registeredSchemaPlugins = pluginRegistry.getAllSchema(overrideSchemaNames);
+  const allPlugins = [...registeredPlugins, ...options.plugins || []];
+  const allSchemaPlugins = [
+    ...registeredSchemaPlugins,
+    ...options.schemaPlugins || []
+  ];
+  const syncOptions = {
+    ...options,
+    plugins: allPlugins.filter(({ usesAsync }) => !usesAsync),
+    schemaPlugins: allSchemaPlugins,
+    async: false
+  };
+  const results = await Promise.all(
+    transactions.map(async (tx) => {
+      const initialResult = await decodeTransaction(tx, syncOptions);
+      const initialData = deepFreeze(initialResult || createErrorResult(tx));
+      const txSignal = signal2({
+        loading: false,
+        data: initialData,
+        decodingStatus: initialResult ? "decoded" : "failed",
+        addresses: collectDataKeys(tx),
+        addressesResolved: false,
+        lastUpdated: Date.now()
+      });
+      return {
+        transaction: tx,
+        immediate: initialData,
+        signal: txSignal
+      };
+    })
+  );
+  const hasAsyncPlugins = true;
+  const pluginsEnabled = isAsyncOperationEnabled(
+    options.async,
+    1 /* ENABLE_PLUGINS */
+  );
+  if (hasAsyncPlugins && pluginsEnabled) {
+    const asyncOptions = {
+      ...options,
+      plugins: allPlugins,
+      schemaPlugins: allSchemaPlugins,
+      async: true
+    };
+    for (const { transaction, signal: txSignal } of results) {
+      decodeTransaction(transaction, asyncOptions).then((enhanced) => {
+        if (enhanced) {
+          txSignal.value = {
+            ...txSignal.value,
+            data: deepFreeze(enhanced),
+            decodingStatus: "enhanced",
+            addresses: collectDataKeys(enhanced),
+            lastUpdated: Date.now()
+          };
+        }
+      }).catch((error) => {
+        console.error("Async decode error:", error);
+        txSignal.value = {
+          ...txSignal.value,
+          decodingStatus: "failed",
+          error: error instanceof Error ? error.message : "Unknown error",
+          loading: false
+        };
+      });
+    }
+  }
+  const addressResolveEnabled = isAsyncOperationEnabled(
+    options.async,
+    2 /* ENABLE_ADDRESS_RESOLVE */
+  );
+  if (options.addressResolver && addressResolveEnabled) {
+    const allAddresses = /* @__PURE__ */ new Set();
+    for (const { signal: txSignal } of results) {
+      for (const addr of txSignal.value.addresses) {
+        allAddresses.add(addr);
+      }
+    }
+    if (allAddresses.size > 0) {
+      options.addressResolver.resolveAddresses(Array.from(allAddresses)).then(() => {
+        for (const { signal: txSignal } of results) {
+          if (txSignal.value.decodingStatus !== "failed") {
+            txSignal.value = {
+              ...txSignal.value,
+              addressesResolved: true,
+              decodingStatus: "complete",
+              lastUpdated: Date.now()
+            };
+          }
+        }
+      }).catch((error) => {
+        console.error("Address resolution error:", error);
+      });
+    }
+  } else if (!hasAsyncPlugins || !pluginsEnabled && !addressResolveEnabled) {
+    for (const { signal: txSignal } of results) {
+      if (txSignal.value.decodingStatus !== "failed") {
+        txSignal.value = {
+          ...txSignal.value,
+          decodingStatus: "complete"
+        };
+      }
+    }
+  }
+  return results.map((r) => ({
+    immediate: r.immediate,
+    signal: r.signal
+  }));
+}
+__name(decodeTransactionBatch, "decodeTransactionBatch");
+function createErrorResult(transaction) {
+  return {
+    ...transaction,
+    resultType: "error",
+    isDecoded: false,
+    errorType: "ERROR" /* ERROR */,
+    sig: transaction.input?.slice(0, 10),
+    error: {
+      code: ERROR_CODES.DECODING_FAILED,
+      message: "Failed to decode transaction",
+      details: new Error("Decoder returned undefined")
+    }
+  };
+}
+__name(createErrorResult, "createErrorResult");
+async function decodeTransactionAsync(transaction, options) {
+  const isBatch = Array.isArray(transaction);
+  const result = await decodeTransaction2(transaction, options);
+  const results = isBatch ? result : [result];
+  const finalResults = await Promise.all(
+    results.map(
+      ({ signal: signal3 }) => new Promise((resolve) => {
+        const checkComplete = /* @__PURE__ */ __name(() => {
+          const state = signal3.value;
+          if (state.decodingStatus === "complete" || state.decodingStatus === "failed") {
+            resolve(state.data);
+          } else {
+            setTimeout(checkComplete, 10);
+          }
+        }, "checkComplete");
+        checkComplete();
+      })
+    )
+  );
+  if (isBatch) {
+    return finalResults;
+  }
+  return finalResults[0];
+}
+__name(decodeTransactionAsync, "decodeTransactionAsync");
+
+export {
+  createDataModel,
+  dataModel,
+  consumerModel,
+  createGlobalInstance,
+  decodeTransaction2 as decodeTransaction,
+  decodeTransactionAsync
+};
+//# sourceMappingURL=chunk-GXZOF3QY.js.map