diff --git a/offchain/package.json b/offchain/package.json
index eec6436..de7dd48 100644
--- a/offchain/package.json
+++ b/offchain/package.json
@@ -38,6 +38,7 @@
     "test": "vitest run"
   },
   "devDependencies": {
+    "@meshsdk/scalus-emulator": "^1.9.1",
     "@parcel/packager-ts": "2.12.0",
     "@parcel/transformer-typescript-types": "2.12.0",
     "@types/node": "^20",
@@ -49,6 +50,6 @@
     "@sinclair/typebox": "^0.32.27"
   },
   "peerDependencies": {
-    "lucid-cardano": "^0.10.10"
+    "@meshsdk/core": "^1.9.1"
   }
 }
diff --git a/offchain/src/aiken.ts b/offchain/src/aiken.ts
index 7a7baf9..231a3bc 100644
--- a/offchain/src/aiken.ts
+++ b/offchain/src/aiken.ts
@@ -1,10 +1,10 @@
 /// Schema for aiken stdlib types added here as needed.
 /// Some schema definitions were liberally taken from
 /// https://github.com/spacebudz/nebula/blob/main/common/utils.ts
-import { Constr, fromText, getAddressDetails, type Address, type Lucid } from 'lucid-cardano';
+import { deserializeAddress, pubKeyAddress, scriptAddress, serializeAddressObj, stringToHex } from '@meshsdk/core';
 
 import { TimeWindow } from './common';
-import { Data } from './data';
+import { Constr, Data } from './data';
 
 export const PolicyIdSchema = Data.Bytes({ minLength: 28, maxLength: 28 });
 
@@ -142,7 +142,7 @@ export function toTimeWindow(interval: PosixTimeIntervalType): TimeWindow {
 export function asChainMap(data: Record<string, unknown>): Map<string, Data> {
   const metadata: Map<string, Data> = new Map();
   for (const [key, value] of Object.entries(data)) {
-    const encodedKey = fromText(key);
+    const encodedKey = stringToHex(key);
     const encodedValue = typeof value == 'boolean' ? asChainBoolean(value) : Data.fromJson(value);
     metadata.set(encodedKey, encodedValue);
   }
@@ -157,26 +157,23 @@ export function asChainBoolean(bool: boolean) {
 }
 
 /// Converts a Bech32 address to the aiken representation of a chain address
-export function asChainAddress(address: Address): ChainAddress {
-  const { paymentCredential, stakeCredential } = getAddressDetails(address);
+export function asChainAddress(address: string): ChainAddress {
+  const { pubKeyHash, scriptHash, stakeCredentialHash, stakeScriptCredentialHash } = deserializeAddress(address);
 
-  if (!paymentCredential) throw new Error('Not a valid payment address.');
+  if (!pubKeyHash && !scriptHash) throw new Error('Not a valid payment address.');
+
+  const stakeHash = stakeCredentialHash || stakeScriptCredentialHash;
 
   return {
-    paymentCredential:
-      paymentCredential?.type === 'Key'
-        ? {
-            VerificationKeyCredential: [paymentCredential.hash],
-          }
-        : { ScriptCredential: [paymentCredential.hash] },
-    stakeCredential: stakeCredential
+    paymentCredential: pubKeyHash
+      ? { VerificationKeyCredential: [pubKeyHash] }
+      : { ScriptCredential: [scriptHash] },
+    stakeCredential: stakeHash
       ? {
           Inline: [
-            stakeCredential.type === 'Key'
-              ? {
-                  VerificationKeyCredential: [stakeCredential.hash],
-                }
-              : { ScriptCredential: [stakeCredential.hash] },
+            stakeCredentialHash
+              ? { VerificationKeyCredential: [stakeCredentialHash] }
+              : { ScriptCredential: [stakeScriptCredentialHash] },
           ],
         }
       : null,
@@ -184,28 +181,32 @@ export function asChainAddress(address: Address): ChainAddress {
 }
 
 /// Converts a aiken chain address to a bech32 address
-export function toBech32Address(lucid: Lucid, address: ChainAddress): Address {
-  // Slightly silly lucid contains utils which references lucid only for a single field 'network'
-  const { utils } = lucid;
-
-  const paymentCredential = (() => {
-    if ('VerificationKeyCredential' in address.paymentCredential) {
-      return utils.keyHashToCredential(address.paymentCredential.VerificationKeyCredential[0]);
-    } else {
-      return utils.scriptHashToCredential(address.paymentCredential.ScriptCredential[0]);
-    }
-  })();
+export function toBech32Address(networkId: number, address: ChainAddress): string {
   const stakeCredential = (() => {
-    if (!address.stakeCredential) return undefined;
-    if ('Inline' in address.stakeCredential) {
-      if ('VerificationKeyCredential' in address.stakeCredential.Inline[0]) {
-        return utils.keyHashToCredential(address.stakeCredential.Inline[0].VerificationKeyCredential[0]);
-      } else {
-        return utils.scriptHashToCredential(address.stakeCredential.Inline[0].ScriptCredential[0]);
-      }
-    } else {
+    if (!address.stakeCredential || !('Inline' in address.stakeCredential)) {
       return undefined;
     }
+
+    const credential = address.stakeCredential.Inline[0];
+    if ('ScriptCredential' in credential) {
+      return { hash: credential.ScriptCredential[0], isScript: true };
+    }
+    return { hash: credential.VerificationKeyCredential[0], isScript: false };
   })();
-  return utils.credentialToAddress(paymentCredential, stakeCredential);
+
+  if ('ScriptCredential' in address.paymentCredential) {
+    const addressObj = scriptAddress(
+      address.paymentCredential.ScriptCredential[0],
+      stakeCredential?.hash,
+      stakeCredential?.isScript
+    );
+    return serializeAddressObj(addressObj, networkId);
+  }
+
+  const addressObj = pubKeyAddress(
+    address.paymentCredential.VerificationKeyCredential[0],
+    stakeCredential?.hash,
+    stakeCredential?.isScript
+  );
+  return serializeAddressObj(addressObj, networkId);
 }
diff --git a/offchain/src/cip-102.ts b/offchain/src/cip-102.ts
index 18e345a..522e7d4 100644
--- a/offchain/src/cip-102.ts
+++ b/offchain/src/cip-102.ts
@@ -1,11 +1,13 @@
-import { fromText, toUnit, type Tx } from 'lucid-cardano';
+import { stringToHex, type MeshTxBuilder } from '@meshsdk/core';
 
 import { asChainAddress, ChainAddressSchema } from './aiken';
 import { Data } from './data';
 import { Royalty } from './royalty';
+import type { ScriptInfo } from './script';
+import { toUnit } from './utils';
 
 export const ROYALTY_TOKEN_LABEL = 500;
-export const ROYALTY_TOKEN_NAME = fromText('Royalty');
+export const ROYALTY_TOKEN_NAME = stringToHex('Royalty');
 
 export const RoyaltyRecipientSchema = Data.Object({
   address: ChainAddressSchema,
@@ -39,8 +41,7 @@ export function asChainVariableFee(percent: number) {
 
 /// Converts from a on chain royalty to a percent between 0 and 100
 export function fromChainVariableFee(fee: bigint) {
-  if(fee <= 0)
-    throw new Error("Chain fee can't be zero or below.");
+  if (fee <= 0) throw new Error("Chain fee can't be zero or below.");
   return Math.ceil(Number(10000n / fee)) / 10;
 }
 
@@ -83,16 +84,20 @@ export function toCip102RoyaltyDatum(royalties: Royalty[]) {
 }
 
 export function addCip102RoyaltyToTransaction(
-  tx: Tx,
-  policyId: string,
+  tx: MeshTxBuilder,
+  mintScript: ScriptInfo,
   address: string,
   royalties: Royalty[],
-  redeemer?: string
+  redeemer: string
 ) {
-  const royaltyUnit = toRoyaltyUnit(policyId);
-  const royaltyAsset = { [royaltyUnit]: 1n };
+  const royaltyUnit = toRoyaltyUnit(mintScript.policyId);
+  const assetName = royaltyUnit.slice(mintScript.policyId.length);
   const royaltyDatum = toCip102RoyaltyDatum(royalties);
-  const royaltyOutputData = { inline: royaltyDatum };
 
-  tx.mintAssets(royaltyAsset, redeemer).payToAddressWithData(address, royaltyOutputData, royaltyAsset);
+  tx.mintPlutusScript(mintScript.script.version)
+    .mint('1', mintScript.policyId, assetName)
+    .mintingScript(mintScript.script.code)
+    .mintRedeemerValue(redeemer, 'CBOR')
+    .txOut(address, [{ unit: royaltyUnit, quantity: '1' }])
+    .txOutInlineDatumValue(royaltyDatum, 'CBOR');
 }
diff --git a/offchain/src/cip-88.test.ts b/offchain/src/cip-88.test.ts
index 3e52d1e..95d4bc7 100644
--- a/offchain/src/cip-88.test.ts
+++ b/offchain/src/cip-88.test.ts
@@ -11,19 +11,22 @@ import {
   TokenProjectDetailField,
 } from './cip-88';
 import { parameterizeMintingPolicy } from './contract';
-import contractsUrl from './contracts-url';
 import { TEST_COLLECTION_INFO } from './fixtures.test';
 import { fetchContracts } from './script';
-import { createEmulatorLucid } from './support.test';
+import { createEmulatorContext } from './support.test';
 
 test('Build CIP-88 metadata', async () => {
-  const { lucid, seedUtxo } = await createEmulatorLucid();
+  const { mesh, seedUtxo } = await createEmulatorContext();
 
-  const contracts = await fetchContracts(contractsUrl);
+  if (!mesh.wallet) {
+    throw new Error('Test context must have a wallet selected');
+  }
 
-  const mintingPolicy = parameterizeMintingPolicy(lucid, contracts, seedUtxo.txHash, seedUtxo.outputIndex);
+  const contracts = await fetchContracts('local');
+
+  const mintingPolicy = parameterizeMintingPolicy(mesh, contracts, seedUtxo.input.txHash, seedUtxo.input.outputIndex);
   const policyId = `0x${mintingPolicy.policyId}`;
-  const address = await lucid.wallet.address();
+  const address = await mesh.wallet.getChangeAddress();
   const info = TEST_COLLECTION_INFO;
   const royalty = { address, variableFee: 1.2 };
   const assetName = '';
@@ -35,7 +38,7 @@ test('Build CIP-88 metadata', async () => {
     .cip102Royalties([royalty])
     .oracle(oracleUri)
     .validateWithbeacon(mintingPolicy.policyId)
-    .build(lucid);
+    .build(mesh);
 
   expect(metadata[RegistrationMetadataField.VERSION] === 1, 'CIP 88 Version 1');
   expect(metadata[RegistrationMetadataField.WITNESS][0].length === 0, 'Beacon validation uses empty witness set');
diff --git a/offchain/src/cip-88.ts b/offchain/src/cip-88.ts
index 1b1f6a1..e5d4f63 100644
--- a/offchain/src/cip-88.ts
+++ b/offchain/src/cip-88.ts
@@ -1,11 +1,12 @@
 /// CIP-88 definitions and builder
-import { fromUnit, type Lucid, type Script, type Tx } from 'lucid-cardano';
+import { resolveScriptHash, type MeshTxBuilder, type PlutusScript } from '@meshsdk/core';
 
 import { asChainVariableFee } from './cip-102';
 import { CollectionImage, CollectionInfo } from './collection-info';
 import { IMAGE_PURPOSE } from './image';
+import type { MeshContext } from './mesh';
 import { Royalty } from './royalty';
-import { chunk } from './utils';
+import { chunk, fromUnit, removeEmpty } from './utils';
 
 export const CIP_88_METADATA_LABEL = 867;
 
@@ -271,16 +272,16 @@ export function toCip102RoyaltyDetail(royalties: Royalty[]): Cip102RoyaltyDetail
 }
 
 export class Cip88Builder {
-  #script: Script;
+  #script: PlutusScript;
   #beacon?: string;
   #features: RegistrationFeatureDetails = {};
   #oracle?: string;
 
-  private constructor(script: Script) {
+  private constructor(script: PlutusScript) {
     this.#script = script;
   }
 
-  public static register(script: Script) {
+  public static register(script: PlutusScript) {
     return new Cip88Builder(script);
   }
 
@@ -316,21 +317,26 @@ export class Cip88Builder {
     return this;
   }
 
-  async build(lucid: Lucid): Promise<RegistrationMetadata> {
-    if (!lucid.wallet) {
-      throw new Error('Must provide an instance of lucide with a selected wallet');
+  async build(mesh: MeshContext): Promise<RegistrationMetadata> {
+    if (!mesh.wallet) {
+      throw new Error('Must provide a mesh context with a selected wallet');
     }
 
-    const payload = this.buildPayload(lucid);
+    const payload = this.buildPayload();
+
+    // Optional fields (e.g. a missing banner image) are present as explicit `undefined` values in
+    // the built objects; Mesh's metadata converter throws on those, so strip them before the payload
+    // is signed or embedded so the signed bytes match what actually ends up on-chain.
+    removeEmpty(payload);
 
     // FIXME: I am not sure if we leave the witness section empty when we use a beacon token.
     let witness: string[][] = [[]];
     if (!this.#beacon) {
-      const address = await lucid.wallet.address();
+      const address = await mesh.wallet.getChangeAddress();
       // FIXME: This seems wrong. The standard under 3. Validation Method says:
       // "The payload to be signed should be the hex-encoded CBOR representation of the Registration Payload object."
       // so I think I might need to declare a complete data schema for CIP-88 and use Data.to(...) to get correct cbor hex.
-      const result = await lucid.wallet.signMessage(address, JSON.stringify(payload));
+      const result = await mesh.wallet.signData(JSON.stringify(payload), address);
       // Probably should also add `0x` to these to convert them into byte arrays in the metadata
       witness = [[result.key, result.signature]];
     }
@@ -353,8 +359,8 @@ export class Cip88Builder {
     return this;
   }
 
-  private buildPayload(lucid: Lucid): RegistrationPayload {
-    const scope = this.buildScope(lucid);
+  private buildPayload(): RegistrationPayload {
+    const scope = this.buildScope();
     let validationMethod: RegistrationValidationMethod | undefined;
     if (this.#beacon) {
       const { policyId, assetName } = fromUnit(this.#beacon);
@@ -379,26 +385,23 @@ export class Cip88Builder {
     };
   }
 
-  private buildScope(lucid: Lucid): RegistrationScope {
-    const policyId = `0x${lucid.utils.validatorToScriptHash(this.#script)}`;
+  private buildScope(): RegistrationScope {
+    const policyId = `0x${resolveScriptHash(this.#script.code, this.#script.version)}`;
 
-    if (this.#script.type === 'Native') {
-      const scriptChunks = chunk(this.#script.script, 64, '0x');
-      return [SCOPE_NATIVE, [policyId, scriptChunks]];
-    } else if (this.#script.type === 'PlutusV1') {
+    if (this.#script.version === 'V1') {
       return [SCOPE_PLUTUS_V1, [policyId]];
-    } else if (this.#script.type === 'PlutusV2') {
+    } else if (this.#script.version === 'V2') {
       return [SCOPE_PLUTUS_V2, [policyId]];
     }
 
-    throw Error(`Could not determine scope. Unexpected script type ${this.#script.type}`);
+    throw Error(`Could not determine scope. Unexpected script version ${this.#script.version}`);
   }
 }
 
 export async function addCip88MetadataToTransaction(
-  lucid: Lucid,
-  tx: Tx,
-  script: Script,
+  mesh: MeshContext,
+  tx: MeshTxBuilder,
+  script: PlutusScript,
   beaconUnit: string,
   config: Cip88ExtraConfig | undefined = undefined
 ) {
@@ -418,6 +421,10 @@ export async function addCip88MetadataToTransaction(
     }
   }
 
-  const metadata = await builder.build(lucid);
-  return tx.attachMetadataWithConversion(CIP_88_METADATA_LABEL, metadata);
+  const metadata = await builder.build(mesh);
+  // NOTE: lucid-cardano's attachMetadataWithConversion converted any '0x'-prefixed string into raw
+  // bytes in the CBOR metadata; Mesh has no equivalent, so '0x'-prefixed values here (policyId,
+  // witness key/signature) are encoded as plain text instead of bytes. See the FIXMEs above -- this
+  // encoding was already flagged as uncertain before this migration.
+  return tx.metadataValue(CIP_88_METADATA_LABEL, metadata);
 }
diff --git a/offchain/src/collection-info.ts b/offchain/src/collection-info.ts
index 07c7017..0a15acb 100644
--- a/offchain/src/collection-info.ts
+++ b/offchain/src/collection-info.ts
@@ -1,10 +1,11 @@
-import { fromText, toText, type Lucid, type UTxO } from 'lucid-cardano';
+import { hexToString, stringToHex, type UTxO } from '@meshsdk/core';
 
 import { toBech32Address } from './aiken';
 import { createReferenceData } from './cip-68';
 import { fromChainVariableFee, RoyaltyInfoShape, RoyaltyInfoType, toRoyaltyUnit } from './cip-102';
 import { Data } from './data';
 import { IMAGE_PURPOSE, ImageDimension, ImagePurpose } from './image';
+import { fetchUtxoByUnit, networkId, type MeshContext } from './mesh';
 import { Royalty } from './royalty';
 import { ScriptCache } from './script';
 import { asChunkedHex, toJoinedText } from './utils';
@@ -85,7 +86,7 @@ export function asChainCollectionImage(image: CollectionImage): CollectionImageT
   const dimension = image.dimension
     ? { width: BigInt(image.dimension.width), height: BigInt(image.dimension.height) }
     : null;
-  const media_type = image.mediaType ? fromText(image.mediaType) : null;
+  const media_type = image.mediaType ? stringToHex(image.mediaType) : null;
   const src = asChunkedHex(image.src);
 
   return {
@@ -101,7 +102,7 @@ export function toCollectionImage(chainImage: CollectionImageType): CollectionIm
   const dimension = chainImage.dimension
     ? { width: Number(chainImage.dimension.width), height: Number(chainImage.dimension.height) }
     : undefined;
-  const mediaType = chainImage.media_type ? toText(chainImage.media_type) : undefined;
+  const mediaType = chainImage.media_type ? hexToString(chainImage.media_type) : undefined;
   const src = toJoinedText(chainImage.src);
 
   return {
@@ -113,18 +114,18 @@ export function toCollectionImage(chainImage: CollectionImageType): CollectionIm
 }
 
 export function asChainCollectionInfo(info: CollectionInfo): CollectionInfoMetadataType {
-  const name = fromText(info.name);
-  const artist = info.artist ? fromText(info.artist) : null;
-  const project = info.project ? fromText(info.project) : null;
+  const name = stringToHex(info.name);
+  const artist = info.artist ? stringToHex(info.artist) : null;
+  const project = info.project ? stringToHex(info.project) : null;
   const nsfw = info.nsfw ? true : false;
   const description = info.description ? asChunkedHex(info.description) : [];
   const images = info.images ? info.images.map(asChainCollectionImage) : [];
-  const traits = info.traits ? info.traits.map(fromText) : [];
+  const traits = info.traits ? info.traits.map(stringToHex) : [];
   const links = new Map<string, string[]>();
 
   if (info.links) {
     for (const [key, value] of Object.entries(info.links)) {
-      links.set(fromText(key), asChunkedHex(value));
+      links.set(stringToHex(key), asChunkedHex(value));
     }
   }
 
@@ -147,20 +148,20 @@ export function asChainCollectionInfo(info: CollectionInfo): CollectionInfoMetad
 
 export function toCollectionInfo(chainInfo: CollectionInfoMetadataType): CollectionInfo {
   const { metadata } = chainInfo;
-  const name = toText(metadata.name);
-  const artist = metadata.artist ? toText(metadata.artist) : undefined;
-  const project = metadata.project ? toText(metadata.project) : undefined;
+  const name = hexToString(metadata.name);
+  const artist = metadata.artist ? hexToString(metadata.artist) : undefined;
+  const project = metadata.project ? hexToString(metadata.project) : undefined;
   const nsfw = metadata.nsfw;
   const description = metadata.description.length ? toJoinedText(metadata.description) : undefined;
   const images = metadata.images.length ? metadata.images.map(toCollectionImage) : undefined;
-  const traits = metadata.traits.length ? metadata.traits.map(toText) : undefined;
+  const traits = metadata.traits.length ? metadata.traits.map(hexToString) : undefined;
 
   let links: Record<string, string> | undefined = undefined;
   if (metadata.links) {
     links = {};
 
     for (const [key, value] of metadata.links) {
-      links[toText(key)] = toJoinedText(value);
+      links[hexToString(key)] = toJoinedText(value);
     }
   }
 
@@ -169,7 +170,7 @@ export function toCollectionInfo(chainInfo: CollectionInfoMetadataType): Collect
     extra = {};
 
     for (const [key, value] of metadata.extra) {
-      extra[toText(key)] = value;
+      extra[hexToString(key)] = value;
     }
   }
 
@@ -187,17 +188,21 @@ export function toCollectionInfo(chainInfo: CollectionInfoMetadataType): Collect
 }
 
 // Decode CBOR datum of passed in UTxO and then convert the plutus data into offchain data
-export async function extractCollectionInfo(lucid: Lucid, utxo: UTxO) {
-  const chainInfo = await lucid.datumOf(utxo, CollectionInfoMetadataShape);
+export async function extractCollectionInfo(utxo: UTxO) {
+  if (!utxo.output.plutusData) {
+    throw new Error('UTxO does not have an inline datum to decode collection info from.');
+  }
+
+  const chainInfo = Data.from(utxo.output.plutusData, CollectionInfoMetadataShape);
   return toCollectionInfo(chainInfo);
 }
 
-export function toRoyaltyInfo(lucid: Lucid, chainInfo: RoyaltyInfoType): Royalty[] {
+export function toRoyaltyInfo(network: number, chainInfo: RoyaltyInfoType): Royalty[] {
   const { metadata } = chainInfo;
   let royalties: Royalty[] = [];
   metadata.forEach((royalty) => {
     royalties.push({
-      address: toBech32Address(lucid, royalty.address),
+      address: toBech32Address(network, royalty.address),
       variableFee: fromChainVariableFee(royalty.variableFee),
       minFee: royalty.minFee ? Number(royalty.minFee) : undefined,
       maxFee: royalty.maxFee ? Number(royalty.maxFee) : undefined,
@@ -207,12 +212,12 @@ export function toRoyaltyInfo(lucid: Lucid, chainInfo: RoyaltyInfoType): Royalty
   return royalties;
 }
 
-export async function extractRoyaltyInfo(lucid: Lucid, policy: string) {
+export async function extractRoyaltyInfo(mesh: MeshContext, policy: string) {
   try {
-    const utxo = await lucid.utxoByUnit(toRoyaltyUnit(policy));
-    if (utxo) {
-      const chainInfo = await lucid.datumOf(utxo, RoyaltyInfoShape);
-      return toRoyaltyInfo(lucid, chainInfo);
+    const utxo = await fetchUtxoByUnit(mesh.provider, toRoyaltyUnit(policy));
+    if (utxo && utxo.output.plutusData) {
+      const chainInfo = Data.from(utxo.output.plutusData, RoyaltyInfoShape);
+      return toRoyaltyInfo(networkId(mesh), chainInfo);
     } else return undefined;
   } catch (err) {
     console.log('Error getting royalties');
@@ -222,11 +227,11 @@ export async function extractRoyaltyInfo(lucid: Lucid, policy: string) {
 }
 
 export async function fetchCollectionInfo(cache: ScriptCache) {
-  const lucid = cache.lucid();
+  const mesh = cache.mesh();
   const unit = cache.unit().info;
-  const utxo = await lucid.utxoByUnit(unit);
+  const utxo = await fetchUtxoByUnit(mesh.provider, unit);
   if (utxo) {
-    return extractCollectionInfo(lucid, utxo);
+    return extractCollectionInfo(utxo);
   } else {
     return undefined;
   }
diff --git a/offchain/src/collection-state.ts b/offchain/src/collection-state.ts
index 824f03d..27772e2 100644
--- a/offchain/src/collection-state.ts
+++ b/offchain/src/collection-state.ts
@@ -1,6 +1,6 @@
 /// On chain schema for the collection state data. For more details on the purpose of the
 
-import { type Lucid, type UTxO } from 'lucid-cardano';
+import { type UTxO } from '@meshsdk/core';
 
 import {
   asChainAddress,
@@ -75,13 +75,17 @@ export function toStateUnit(policyId: string) {
 }
 
 // Decode CBOR datum of passed in UTxO and then convert the plutus data into offchain data
-export async function extractCollectionState(lucid: Lucid, utxo: UTxO) {
-  const chainState = await lucid.datumOf(utxo, CollectionStateMetadataShape);
-  return toCollectionState(lucid, chainState);
+export async function extractCollectionState(utxo: UTxO, networkId: number) {
+  if (!utxo.output.plutusData) {
+    throw new Error('UTxO does not have an inline datum to decode collection state from.');
+  }
+
+  const chainState = Data.from(utxo.output.plutusData, CollectionStateMetadataShape);
+  return toCollectionState(chainState, networkId);
 }
 
 /// Convert from on chain plutus data to off chain data structure
-export function toCollectionState(lucid: Lucid, chainState: CollectionStateMetadataType): CollectionState {
+export function toCollectionState(chainState: CollectionStateMetadataType, networkId: number): CollectionState {
   const { metadata } = chainState;
   const chainInfo = metadata.info;
 
@@ -92,7 +96,7 @@ export function toCollectionState(lucid: Lucid, chainState: CollectionStateMetad
     mintWindow: chainInfo.mint_window ? toTimeWindow(chainInfo.mint_window) : undefined,
     maxNfts: chainInfo.max_nfts ? Number(chainInfo.max_nfts) : undefined,
     nftValidatorAddress: chainInfo.nft_validator_address
-      ? toBech32Address(lucid, chainInfo.nft_validator_address)
+      ? toBech32Address(networkId, chainInfo.nft_validator_address)
       : undefined,
     scriptReferencePolicyId: chainInfo.script_reference_policy_id,
   };
diff --git a/offchain/src/collection.ts b/offchain/src/collection.ts
index 0711f8d..dc7d285 100644
--- a/offchain/src/collection.ts
+++ b/offchain/src/collection.ts
@@ -1,6 +1,7 @@
-import { fromText, toLabel, toUnit } from 'lucid-cardano';
+import { stringToHex } from '@meshsdk/core';
 
 import { NFT_TOKEN_LABEL, REFERENCE_TOKEN_LABEL } from './cip-68';
+import { toLabel, toUnit } from './utils';
 
 /// Speical collection owner token label.
 /// Selected because it has similar pattern to other labels, there is no standard.
@@ -52,7 +53,7 @@ function toNftAssetName(label: number, sequence: number, content: string) {
     content = content.substring(0, CONTENT_NAME_MAX_BYTES);
   }
 
-  return `${toLabel(label)}${toPurposeHex(COLLECTION_TOKEN_PURPOSE.NFT)}${toSequenceHex(sequence)}${fromText(content)}`;
+  return `${toLabel(label)}${toPurposeHex(COLLECTION_TOKEN_PURPOSE.NFT)}${toSequenceHex(sequence)}${stringToHex(content)}`;
 }
 
 /// Construct a unit from the collection specific parts that compose the unit name
@@ -82,7 +83,7 @@ export function toNftUserUnit(policyId: string, sequence: number, content: strin
 
 /// Construct management token unit from policy id and label
 function toManageUnit(policyId: string, label: number) {
-  const name = `${toPurposeHex(COLLECTION_TOKEN_PURPOSE.Management)}${fromText('Collection')}`;
+  const name = `${toPurposeHex(COLLECTION_TOKEN_PURPOSE.Management)}${stringToHex('Collection')}`;
   return toUnit(policyId, name, label);
 }
 
diff --git a/offchain/src/contract.ts b/offchain/src/contract.ts
index 73494ff..854b7c4 100644
--- a/offchain/src/contract.ts
+++ b/offchain/src/contract.ts
@@ -1,18 +1,20 @@
-import { applyParamsToScript, fromText, Script, toLabel, UTxO, type Lucid } from 'lucid-cardano';
+import { applyParamsToScript, stringToHex, type MeshTxBuilder, type PlutusScript, type UTxO } from '@meshsdk/core';
 
 import { OutputReferenceSchema, PolicyIdSchema, PubKeyHashSchema } from './aiken';
-import { Data } from './data';
-import { Contracts, fetchOwnerUtxo, fetchUtxo, getScript, getScriptInfo, ScriptCache } from './script';
+import { Data, toMeshParams } from './data';
+import { newTxBuilder, unixTimeToSlot, type MeshContext } from './mesh';
+import { fetchOwnerUtxo, fetchUtxo, getScript, getScriptInfo, ScriptCache, type Contracts } from './script';
+import { toLabel } from './utils';
 
 export const ScriptName = {
-  NftMintingPolicy: 'mint.mint',
-  DerivativeMintingPolicy: 'derivative.mint',
-  DelegateMintingPolicy: 'delegate.mint',
-  MintingStateValidator: 'state.spend',
-  ImmutableInfoValidator: 'immutable_info.spend',
-  ImmutableNftValidator: 'immutable_nft.spend',
-  PermissiveNftValidator: 'permissive_nft.spend',
-  SpendLockValidator: 'lock.spend',
+  NftMintingPolicy: 'mint.mint_script.mint',
+  DerivativeMintingPolicy: 'derivative.derivative_script.mint',
+  DelegateMintingPolicy: 'delegate.delegate_script.mint',
+  MintingStateValidator: 'state.state_script.spend',
+  ImmutableInfoValidator: 'immutable_info.imm_info_script.spend',
+  ImmutableNftValidator: 'immutable_nft.imm_nft_script.spend',
+  PermissiveNftValidator: 'permissive_nft.perm_nft_script.spend',
+  SpendLockValidator: 'lock.lock_script.spend',
 } as const;
 
 /// Minting policy paramaterization schema
@@ -49,18 +51,18 @@ export const StateValidatorRedeemerShape = StateValidatorRedeemerSchema as unkno
 
 /// Given a minting policy, parameterizes the collection info reference token spending validator and returns its info
 function paramaterizePolicyIdValidator(
-  lucid: Lucid,
+  mesh: MeshContext,
   contracts: Contracts,
   mintingPolicyId: string,
   scriptName: string
 ) {
   const script = getScript(contracts, scriptName);
-  const paramertizedMintingPolicy = applyParamsToScript<PolicyIdValidatorParameterType>(
+  const paramertizedMintingPolicy = applyParamsToScript(
     script.compiledCode,
-    [mintingPolicyId],
-    PolicyIdValidatorParameterShape
+    toMeshParams<PolicyIdValidatorParameterType>([mintingPolicyId], PolicyIdValidatorParameterShape),
+    'Mesh'
   );
-  return getScriptInfo(lucid, script.title, paramertizedMintingPolicy);
+  return getScriptInfo(mesh, script.title, paramertizedMintingPolicy);
 }
 
 // Script references are not created under the same main minting policy as the collection and nft tokens.
@@ -68,19 +70,23 @@ function paramaterizePolicyIdValidator(
 // In other words the policyId first parameter below is NOT the nft/collection token minting policy id.  It's just
 // some native script minting policy.
 export function scriptReferenceUnit(policyId: string, assetName: string) {
-  return policyId + toLabel(0) + fromText(assetName);
+  return policyId + toLabel(0) + stringToHex(assetName);
 }
 
 // Creates a transaction that uses the passed in minting policy to generate tokens containing
 // script references and sends them to a locked spending validator unique to the main minting policy.
 export async function createScriptReference(
-  lucid: Lucid,
+  mesh: MeshContext,
   cache: ScriptCache,
-  scripts: { script: Script; name: string }[],
+  scripts: { script: PlutusScript; name: string }[],
   type: 'delegate' | 'derivative' = 'derivative',
   delegate?: string,
   ownerUtxo?: UTxO
-) {
+): Promise<MeshTxBuilder> {
+  if (!mesh.wallet) {
+    throw new Error('Must have a wallet selected to build a transaction.');
+  }
+
   const mintingPolicyInfo = getReferenceMintInfo(cache, type, delegate);
   const mintingPolicyId = mintingPolicyInfo.policyId;
   const lockAddress = cache.spendLock().address;
@@ -94,48 +100,45 @@ export async function createScriptReference(
     ownerUtxo = utxo;
   }
 
-  const assets: Record<string, bigint> = {};
+  const tx = newTxBuilder(mesh);
+  tx.changeAddress(await mesh.wallet.getChangeAddress());
+
   for (const { name } of scripts) {
     const unit = scriptReferenceUnit(mintingPolicyId, name);
-    assets[unit] = 1n;
+    const assetName = unit.slice(mintingPolicyId.length);
+    tx.mintPlutusScript(mintingPolicyInfo.script.version)
+      .mint('1', mintingPolicyId, assetName)
+      .mintingScript(mintingPolicyInfo.script.code)
+      .mintRedeemerValue(Data.void(), 'CBOR');
   }
 
-  const tx = await lucid
-    .newTx()
-    .attachMintingPolicy(mintingPolicyInfo.script)
-    .mintAssets(assets, Data.void())
-    .validTo(Date.now() + 2 * 60 * 1000);
+  tx.invalidHereafter(unixTimeToSlot(mesh, Date.now() + 2 * 60 * 1000));
 
   // Spend the owner token if it is included to prove ownership
   if (ownerUtxo) {
-    tx.payToAddress(ownerUtxo.address, { [cache.unit().owner]: 1n });
+    tx.txOut(ownerUtxo.output.address, [{ unit: cache.unit().owner, quantity: '1' }]);
   }
 
   for (const { script, name } of scripts) {
     const unit = scriptReferenceUnit(mintingPolicyId, name);
-    tx.payToContract(
-      lockAddress,
-      {
-        inline: Data.void(),
-        scriptRef: script,
-      },
-      { [unit]: 1n }
-    );
+    tx.txOut(lockAddress, [{ unit, quantity: '1' }])
+      .txOutInlineDatumValue(Data.void(), 'CBOR')
+      .txOutReferenceScript(script.code, script.version);
   }
 
   return tx;
 }
 
 export async function fetchReferenceUtxo(cache: ScriptCache, scriptName: string, delegate?: string) {
-  const lucid = cache.lucid();
+  const mesh = cache.mesh();
   const address = cache.spendLock().address;
   const policyId = delegate ? cache.delegateMint(delegate).policyId : cache.derivativeMint().policyId;
   const unit = scriptReferenceUnit(policyId, scriptName);
-  return await fetchUtxo(lucid, address, unit);
+  return await fetchUtxo(mesh, address, unit);
 }
 
 /// Given a unique hash and index from the seed transaction parameterizes the minting policy and returns its info
-export function parameterizeMintingPolicy(lucid: Lucid, contracts: Contracts, hash: string, index: number) {
+export function parameterizeMintingPolicy(mesh: MeshContext, contracts: Contracts, hash: string, index: number) {
   const seed = {
     transaction_id: {
       hash,
@@ -144,12 +147,12 @@ export function parameterizeMintingPolicy(lucid: Lucid, contracts: Contracts, ha
   };
 
   const script = getScript(contracts, ScriptName.NftMintingPolicy);
-  const paramertizedMintingPolicy = applyParamsToScript<MintParameterType>(
+  const paramertizedMintingPolicy = applyParamsToScript(
     script.compiledCode,
-    [seed],
-    MintParameterShape
+    toMeshParams<MintParameterType>([seed], MintParameterShape),
+    'Mesh'
   );
-  return getScriptInfo(lucid, script.title, paramertizedMintingPolicy);
+  return getScriptInfo(mesh, script.title, paramertizedMintingPolicy);
 }
 
 ///// Rest of these functions are just some utility functions for readability that aren't strictly needed.
@@ -164,21 +167,21 @@ export async function fetchMintingPolicyReferenceUtxo(cache: ScriptCache, delega
 }
 
 export async function createMintingPolicyReference(
-  lucid: Lucid,
+  mesh: MeshContext,
   cache: ScriptCache,
   type: 'delegate' | 'derivative' = 'derivative',
   delegate?: string,
   ownerUtxo?: UTxO
-) {
+): Promise<MeshTxBuilder> {
   const script = cache.mint().script;
   const name = ScriptName.NftMintingPolicy;
 
-  return await createScriptReference(lucid, cache, [{ script, name }], type, delegate, ownerUtxo);
+  return await createScriptReference(mesh, cache, [{ script, name }], type, delegate, ownerUtxo);
 }
 
 /// State Validator
-export function parameterizeStateValidator(lucid: Lucid, contracts: Contracts, mintingPolicyId: string) {
-  return paramaterizePolicyIdValidator(lucid, contracts, mintingPolicyId, ScriptName.MintingStateValidator);
+export function parameterizeStateValidator(mesh: MeshContext, contracts: Contracts, mintingPolicyId: string) {
+  return paramaterizePolicyIdValidator(mesh, contracts, mintingPolicyId, ScriptName.MintingStateValidator);
 }
 
 export function stateValidatorReferenceUnit(policyId: string) {
@@ -190,21 +193,21 @@ export async function fetchStateValidatorReferenceUtxo(cache: ScriptCache, deleg
 }
 
 export async function createStateValidatorReference(
-  lucid: Lucid,
+  mesh: MeshContext,
   cache: ScriptCache,
   type: 'delegate' | 'derivative' = 'derivative',
   delegate?: string,
   ownerUtxo?: UTxO
-) {
+): Promise<MeshTxBuilder> {
   const script = cache.state().script;
   const name = ScriptName.MintingStateValidator;
 
-  return await createScriptReference(lucid, cache, [{ script, name }], type, delegate, ownerUtxo);
+  return await createScriptReference(mesh, cache, [{ script, name }], type, delegate, ownerUtxo);
 }
 
 /// Immutable Info Validator
-export function parameterizeImmutableInfoValidator(lucid: Lucid, contracts: Contracts, mintingPolicyId: string) {
-  return paramaterizePolicyIdValidator(lucid, contracts, mintingPolicyId, ScriptName.ImmutableInfoValidator);
+export function parameterizeImmutableInfoValidator(mesh: MeshContext, contracts: Contracts, mintingPolicyId: string) {
+  return paramaterizePolicyIdValidator(mesh, contracts, mintingPolicyId, ScriptName.ImmutableInfoValidator);
 }
 
 export function immutableInfoReferenceUnit(policyId: string) {
@@ -216,8 +219,8 @@ export async function fetchImmutableInfoReferenceUtxo(cache: ScriptCache, delega
 }
 
 /// Immutable NFT validator
-export function parameterizeImmutableNftValidator(lucid: Lucid, contracts: Contracts, mintingPolicyId: string) {
-  return paramaterizePolicyIdValidator(lucid, contracts, mintingPolicyId, ScriptName.ImmutableNftValidator);
+export function parameterizeImmutableNftValidator(mesh: MeshContext, contracts: Contracts, mintingPolicyId: string) {
+  return paramaterizePolicyIdValidator(mesh, contracts, mintingPolicyId, ScriptName.ImmutableNftValidator);
 }
 
 export function immutableNftReferenceUnit(policyId: string) {
@@ -229,8 +232,8 @@ export async function fetchImmutableNftReferenceUtxo(cache: ScriptCache, delegat
 }
 
 /// Permissive NFT validator
-export function parameterizePermissiveNftValidator(lucid: Lucid, contracts: Contracts, mintingPolicyId: string) {
-  return paramaterizePolicyIdValidator(lucid, contracts, mintingPolicyId, ScriptName.PermissiveNftValidator);
+export function parameterizePermissiveNftValidator(mesh: MeshContext, contracts: Contracts, mintingPolicyId: string) {
+  return paramaterizePolicyIdValidator(mesh, contracts, mintingPolicyId, ScriptName.PermissiveNftValidator);
 }
 
 export function permissiveNftReferenceUnit(policyId: string) {
@@ -242,8 +245,8 @@ export async function fetchPermissiveNftReferenceUtxo(cache: ScriptCache, delega
 }
 
 /// Lock Validator
-export function parameterizeSpendLockValidator(lucid: Lucid, contracts: Contracts, mintingPolicyId: string) {
-  return paramaterizePolicyIdValidator(lucid, contracts, mintingPolicyId, ScriptName.SpendLockValidator);
+export function parameterizeSpendLockValidator(mesh: MeshContext, contracts: Contracts, mintingPolicyId: string) {
+  return paramaterizePolicyIdValidator(mesh, contracts, mintingPolicyId, ScriptName.SpendLockValidator);
 }
 
 export function lockReferenceUnit(policyId: string) {
@@ -255,24 +258,24 @@ export async function fetchLockReferenceUtxo(cache: ScriptCache, delegate?: stri
 }
 
 // Reference minting policy
-export function parameterizeDerivativeMintingPolicy(lucid: Lucid, contracts: Contracts, mintingPolicyId: string) {
-  return paramaterizePolicyIdValidator(lucid, contracts, mintingPolicyId, ScriptName.DerivativeMintingPolicy);
+export function parameterizeDerivativeMintingPolicy(mesh: MeshContext, contracts: Contracts, mintingPolicyId: string) {
+  return paramaterizePolicyIdValidator(mesh, contracts, mintingPolicyId, ScriptName.DerivativeMintingPolicy);
 }
 
 // Reference minting policy
 export function parameterizeDelegativeMintingPolicy(
-  lucid: Lucid,
+  mesh: MeshContext,
   contracts: Contracts,
   mintingPolicyId: string,
   delegatePubKeyHash: string
 ) {
   const script = getScript(contracts, ScriptName.DelegateMintingPolicy);
-  const paramertizedMintingPolicy = applyParamsToScript<DelegateValidatorParameterType>(
+  const paramertizedMintingPolicy = applyParamsToScript(
     script.compiledCode,
-    [mintingPolicyId, delegatePubKeyHash],
-    DelegateValidatorParameterShape
+    toMeshParams<DelegateValidatorParameterType>([mintingPolicyId, delegatePubKeyHash], DelegateValidatorParameterShape),
+    'Mesh'
   );
-  return getScriptInfo(lucid, script.title, paramertizedMintingPolicy);
+  return getScriptInfo(mesh, script.title, paramertizedMintingPolicy);
 }
 
 // Utility for fetching minting policy given a type and script cache
diff --git a/offchain/src/data.ts b/offchain/src/data.ts
index cdf5a80..f3e37a5 100644
--- a/offchain/src/data.ts
+++ b/offchain/src/data.ts
@@ -1,7 +1,7 @@
-/** Copied from lucid-cardano@0.10.7/src/plutus/data.ts. The compiler complains with an error like:
- * error TS2742: The inferred type of 'MyLocalSchema' cannot be named without a reference to '.../node_modules/lucid-cardano/typebox'
- *
- *  I think pomething to do with how lucid exports typebox but for now easiest workaround is to just use NPM version of typebox.
+/** Originally copied from lucid-cardano@0.10.7/src/plutus/data.ts to work around a TS inference bug
+ * where the inferred type of a schema could not be named without a reference to lucid's bundled typebox.
+ * Kept as our own schema DSL across the Mesh SDK migration since none of it is lucid-specific -- only
+ * the low-level to()/from() (de)serialization below is tied to a particular Cardano library.
  */
 import {
   Type,
@@ -12,7 +12,21 @@ import {
   type TProperties,
   type TSchema,
 } from '@sinclair/typebox';
-import { C, fromHex, fromText, toHex, type Datum, type Exact, type Json, type Redeemer } from 'lucid-cardano';
+import {
+  bytesToHex,
+  deserializeDatum,
+  hexToBytes,
+  hexToString,
+  serializeData,
+  stringToHex,
+  type Data as MeshData,
+} from '@meshsdk/core';
+
+/// Prevents excess properties from being inferred as part of the type. Mirrors lucid-cardano's Exact<T>.
+export type Exact<T> = T extends infer U ? U : never;
+
+/// Loose JSON type used internally when walking schema shapes.
+export type Json = any;
 
 export class Constr<T> {
   index: number;
@@ -229,98 +243,76 @@ export const Data = {
    * Note Constr cannot be used here, also only bytes/integers as Json keys.\
    */
   toJson,
-  void: function (): Datum | Redeemer {
+  void: function (): string {
     return 'd87980';
   },
   castFrom,
   castTo,
 };
 
+/// Converts our Constr-based Data union into Mesh's structurally equivalent Data type.
+function toMeshData(data: Data): MeshData {
+  if (data instanceof Constr) {
+    return { alternative: data.index, fields: data.fields.map(toMeshData) };
+  } else if (data instanceof Array) {
+    return data.map(toMeshData);
+  } else if (data instanceof Map) {
+    const map: Map<MeshData, MeshData> = new Map();
+    for (const [key, value] of data.entries()) {
+      map.set(toMeshData(key), toMeshData(value));
+    }
+    return map;
+  }
+  return data;
+}
+
+/// Converts Mesh's Data type back into our Constr-based Data union.
+function fromMeshData(data: MeshData): Data {
+  if (typeof data === 'number') {
+    return BigInt(data);
+  } else if (typeof data === 'bigint' || typeof data === 'string') {
+    return data;
+  } else if (data instanceof Array) {
+    return data.map(fromMeshData);
+  } else if (data instanceof Map) {
+    const map: Map<Data, Data> = new Map();
+    for (const [key, value] of data.entries()) {
+      map.set(fromMeshData(key), fromMeshData(value));
+    }
+    return map;
+  }
+  return new Constr(data.alternative, data.fields.map(fromMeshData));
+}
+
 /**
  * Convert PlutusData to Cbor encoded data.\
  * Or apply a shape and convert the provided data struct to Cbor encoded data.
  */
-function to<T = Data>(data: Exact<T>, type?: T): Datum | Redeemer {
-  function serialize(data: Data): C.PlutusData {
-    try {
-      if (typeof data === 'bigint') {
-        return C.PlutusData.new_integer(C.BigInt.from_str(data.toString()));
-      } else if (typeof data === 'string') {
-        return C.PlutusData.new_bytes(fromHex(data));
-      } else if (data instanceof Constr) {
-        const { index, fields } = data;
-        const plutusList = C.PlutusList.new();
-
-        fields.forEach((field) => plutusList.add(serialize(field)));
-
-        return C.PlutusData.new_constr_plutus_data(
-          C.ConstrPlutusData.new(C.BigNum.from_str(index.toString()), plutusList)
-        );
-      } else if (data instanceof Array) {
-        const plutusList = C.PlutusList.new();
-
-        data.forEach((arg) => plutusList.add(serialize(arg)));
-
-        return C.PlutusData.new_list(plutusList);
-      } else if (data instanceof Map) {
-        const plutusMap = C.PlutusMap.new();
-
-        for (const [key, value] of data.entries()) {
-          plutusMap.insert(serialize(key), serialize(value));
-        }
-
-        return C.PlutusData.new_map(plutusMap);
-      }
-      throw new Error('Unsupported type');
-    } catch (error) {
-      throw new Error('Could not serialize the data: ' + error);
-    }
-  }
+function to<T = Data>(data: Exact<T>, type?: T): string {
   const d = type ? castTo<T>(data, type) : (data as Data);
-  return toHex(serialize(d).to_bytes()) as Datum | Redeemer;
+  return serializeData(toMeshData(d));
 }
 
 /**
  *  Convert Cbor encoded data to Data.\
  *  Or apply a shape and cast the cbor encoded data to a certain type.
  */
-function from<T = Data>(raw: Datum | Redeemer, type?: T): T {
-  function deserialize(data: C.PlutusData): Data {
-    if (data.kind() === 0) {
-      const constr = data.as_constr_plutus_data()!;
-      const l = constr.data();
-      const desL = [];
-      for (let i = 0; i < l.len(); i++) {
-        desL.push(deserialize(l.get(i)));
-      }
-      return new Constr(parseInt(constr.alternative().to_str()), desL);
-    } else if (data.kind() === 1) {
-      const m = data.as_map()!;
-      const desM: Map<Data, Data> = new Map();
-      const keys = m.keys();
-      for (let i = 0; i < keys.len(); i++) {
-        desM.set(deserialize(keys.get(i)), deserialize(m.get(keys.get(i))!));
-      }
-      return desM;
-    } else if (data.kind() === 2) {
-      const l = data.as_list()!;
-      const desL = [];
-      for (let i = 0; i < l.len(); i++) {
-        desL.push(deserialize(l.get(i)));
-      }
-      return desL;
-    } else if (data.kind() === 3) {
-      return BigInt(data.as_integer()!.to_str());
-    } else if (data.kind() === 4) {
-      return toHex(data.as_bytes()!);
-    }
-    throw new Error('Unsupported type');
-  }
-  const data = deserialize(C.PlutusData.from_bytes(fromHex(raw)));
+function from<T = Data>(raw: string, type?: T): T {
+  const data = fromMeshData(deserializeDatum<MeshData>(raw));
 
   return type ? castFrom<T>(data, type) : (data as T);
 }
 
+/// Casts a raw params array against a Data.Tuple schema and converts the result into Mesh's Data
+/// type, ready to pass directly to Mesh's applyParamsToScript.
+export function toMeshParams<T extends unknown[]>(params: Exact<T>, type: T): MeshData[] {
+  const cast = castTo<T>(params, type);
+  if (!(cast instanceof Array)) {
+    throw new Error('toMeshParams expects a Data.Tuple schema.');
+  }
+  return cast.map(toMeshData);
+}
+
 /**
  * Note Constr cannot be used here.\
  * Strings prefixed with '0x' are not UTF-8 encoded.
@@ -328,7 +320,7 @@ function from<T = Data>(raw: Datum | Redeemer, type?: T): T {
 function fromJson(json: Json): Data {
   function toData(json: Json): Data {
     if (typeof json === 'string') {
-      return json.startsWith('0x') ? toHex(fromHex(json.slice(2))) : fromText(json);
+      return json.startsWith('0x') ? bytesToHex(hexToBytes(json.slice(2))) : stringToHex(json);
     }
     if (typeof json === 'number') return BigInt(json);
     if (typeof json === 'bigint') return json;
@@ -360,9 +352,9 @@ function toJson(plutusData: Data): Json {
     }
     if (typeof data === 'string') {
       try {
-        return new TextDecoder(undefined, { fatal: true }).decode(fromHex(data));
+        return hexToString(data);
       } catch (_) {
-        return '0x' + toHex(fromHex(data));
+        return '0x' + data;
       }
     }
     if (data instanceof Array) return data.map((v) => fromData(v));
diff --git a/offchain/src/genesis.test.ts b/offchain/src/genesis.test.ts
index 86ad108..56e6027 100644
--- a/offchain/src/genesis.test.ts
+++ b/offchain/src/genesis.test.ts
@@ -2,17 +2,18 @@ import { expect, test } from 'vitest';
 
 import { TEST_COLLECTION_INFO } from './fixtures.test';
 import { GenesisTxBuilder } from './genesis';
-import { applyTx, createEmulatorLucid } from './support.test';
+import { applyTx, createEmulatorContext } from './support.test';
 
 test('Minimal minting policy genesis transaction', async () => {
-  const { lucid, seedUtxo } = await createEmulatorLucid();
-  const { tx, cache } = await GenesisTxBuilder.create(lucid)
+  const { mesh, seedUtxo } = await createEmulatorContext();
+  const { tx, cache } = await GenesisTxBuilder.create(mesh)
     .info({ name: 'No Constraints', nsfw: false })
     .seed(seedUtxo)
+    .contractsUrl('local')
     .build();
 
   // Check the state is on the datum as expected
-  const { state, info } = await applyTx(lucid, tx, cache);
+  const { state, info } = await applyTx(mesh, tx, cache);
   expect(state.info.group).toBeUndefined();
   expect(state.info.mintWindow).toBeUndefined();
   expect(state.info.maxNfts).toBeUndefined();
@@ -24,13 +25,13 @@ test('Minimal minting policy genesis transaction', async () => {
 });
 
 test('All configuration genesis transaction', async () => {
-  const { lucid, seedUtxo, accounts } = await createEmulatorLucid();
+  const { mesh, seedUtxo, accounts } = await createEmulatorContext();
   // Use different address than selected wallet (account 0)
   const ownerAddress = accounts[1].address;
   const royaltyTokenAddress = accounts[3].address;
   const endMs = Date.now() + 1_000_000;
   const groupPolicyId = 'de2340edc45629456bf695200e8ea32f948a653b21ada10bc6f0c554';
-  const { tx, cache } = await GenesisTxBuilder.create(lucid)
+  const { tx, cache } = await GenesisTxBuilder.create(mesh)
     .seed(seedUtxo)
     .group(groupPolicyId)
     .maxNfts(1)
@@ -41,10 +42,11 @@ test('All configuration genesis transaction', async () => {
     .info(TEST_COLLECTION_INFO)
     .useCip88(true)
     .royalty(accounts[0].address, 4.3)
+    .contractsUrl('local')
     .build();
 
   // Check the state is on the datum as expected
-  const { state, info } = await applyTx(lucid, tx, cache);
+  const { state, info } = await applyTx(mesh, tx, cache);
   expect(info.name === TEST_COLLECTION_INFO.name);
   expect(info.artist === TEST_COLLECTION_INFO.artist);
   expect(info.description === TEST_COLLECTION_INFO.description);
@@ -54,40 +56,40 @@ test('All configuration genesis transaction', async () => {
 });
 
 test('Builder errors during build', async () => {
-  const { lucid } = await createEmulatorLucid();
+  const { mesh } = await createEmulatorContext();
 
   // End time <= Start Time
   expect(() => {
-    GenesisTxBuilder.create(lucid).mintWindow(0, 0);
+    GenesisTxBuilder.create(mesh).mintWindow(0, 0);
   }).toThrowError();
 
   // Invalid policy id
   expect(() => {
-    GenesisTxBuilder.create(lucid).group('This is not a 28 byte hex string');
+    GenesisTxBuilder.create(mesh).group('This is not a 28 byte hex string');
   }).toThrowError();
 
   // Same address twice
   expect(() => {
-    GenesisTxBuilder.create(lucid).royalty('addr1superlegit', 10).royalty('addr1superlegit', 10);
+    GenesisTxBuilder.create(mesh).royalty('addr1superlegit', 10).royalty('addr1superlegit', 10);
   }).toThrowError();
 
   // Greater than 100%
   expect(() => {
-    GenesisTxBuilder.create(lucid).royalty('addr1superlegitA', 60).royalty('addr1superlegitB', 60);
+    GenesisTxBuilder.create(mesh).royalty('addr1superlegitA', 60).royalty('addr1superlegitB', 60);
   }).toThrowError();
 
   // Less that 0.1%
   expect(() => {
-    GenesisTxBuilder.create(lucid).royalty('addr1superlegit', 0.01);
+    GenesisTxBuilder.create(mesh).royalty('addr1superlegit', 0.01);
   }).toThrowError();
 
   // Invalid bech32 royalty address (well more invalid)
   expect(() => {
-    GenesisTxBuilder.create(lucid).royalty('badnotsuperlegit', 0);
+    GenesisTxBuilder.create(mesh).royalty('badnotsuperlegit', 0);
   }).toThrowError();
 
   // Invalid bech32 recipient
   expect(() => {
-    GenesisTxBuilder.create(lucid).ownerAddress('badnotsuperlegit');
+    GenesisTxBuilder.create(mesh).ownerAddress('badnotsuperlegit');
   }).toThrowError();
 });
diff --git a/offchain/src/genesis.ts b/offchain/src/genesis.ts
index 60e64c8..b676d71 100644
--- a/offchain/src/genesis.ts
+++ b/offchain/src/genesis.ts
@@ -1,4 +1,4 @@
-import { type Address, type Lucid, type Script, type UTxO } from 'lucid-cardano';
+import { serializePlutusScript, type MeshTxBuilder, type PlutusScript, type UTxO } from '@meshsdk/core';
 
 import { addCip88MetadataToTransaction, Cip88ExtraConfig } from './cip-88';
 import { addCip102RoyaltyToTransaction } from './cip-102';
@@ -13,12 +13,13 @@ import {
 import { MintRedeemerShape } from './contract';
 import CONTRACTS_URL from './contracts-url';
 import { Data } from './data';
+import { networkId, newTxBuilder, type MeshContext } from './mesh';
 import { Royalty } from './royalty';
 import { fetchContracts, ScriptCache } from './script';
 import { checkPolicyId } from './utils';
 
 export class GenesisTxBuilder {
-  #lucid: Lucid;
+  #mesh: MeshContext;
   #cache?: ScriptCache;
   #seed?: UTxO;
   #info?: CollectionInfo;
@@ -39,18 +40,18 @@ export class GenesisTxBuilder {
   #delegate = '';
   #nftValidator: 'permissive' | 'immutable' | 'custom' = 'immutable';
   #royalties: Record<string, Royalty> = {};
-  #royaltyValidatorAddress?: Address;
+  #royaltyValidatorAddress?: string;
   #ownerAddress?: string;
 
-  private constructor(lucid: Lucid) {
-    this.#lucid = lucid;
+  private constructor(mesh: MeshContext) {
+    this.#mesh = mesh;
   }
 
   seed(seed: UTxO) {
     this.#seed = seed;
     this.#state.info.seed = {
-      hash: seed.txHash,
-      index: seed.outputIndex,
+      hash: seed.input.txHash,
+      index: seed.input.outputIndex,
     };
     return this;
   }
@@ -106,9 +107,9 @@ export class GenesisTxBuilder {
     throw new Error('reference token validator address must be bech32 encoded string');
   }
 
-  nftValidator(validator: Script) {
+  nftValidator(validator: PlutusScript) {
     this.#nftValidator = 'custom';
-    this.#state.info.nftValidatorAddress = this.#lucid.utils.validatorToAddress(validator);
+    this.#state.info.nftValidatorAddress = serializePlutusScript(validator, undefined, networkId(this.#mesh)).address;
     return this;
   }
 
@@ -138,8 +139,8 @@ export class GenesisTxBuilder {
     throw new Error('royalty address must be bech32 encoded string');
   }
 
-  royaltyValidator(validator: Script) {
-    this.#royaltyValidatorAddress = this.#lucid.utils.validatorToAddress(validator);
+  royaltyValidator(validator: PlutusScript) {
+    this.#royaltyValidatorAddress = serializePlutusScript(validator, undefined, networkId(this.#mesh)).address;
     return this;
   }
 
@@ -194,7 +195,7 @@ export class GenesisTxBuilder {
     return this;
   }
 
-  async build() {
+  async build(): Promise<{ cache: ScriptCache; tx: MeshTxBuilder; state: CollectionState; recipient: string }> {
     if (!this.#seed) {
       throw new Error('Missing required field seed. Did you forget to call `seed(utxo)`?');
     }
@@ -203,22 +204,26 @@ export class GenesisTxBuilder {
       throw new Error('Missing required collection information. Did you call `info(info)`?');
     }
 
+    if (!this.#mesh.wallet) {
+      throw new Error('Must have a wallet selected to build a transaction.');
+    }
+
     // Create a script cache from seed utxo so that after build it can be reused if needed
     const cache = this.#cache
       ? this.#cache
-      : ScriptCache.cold(this.#lucid, await fetchContracts(this.#state.info.contractsUrl), this.#seed);
+      : ScriptCache.cold(this.#mesh, await fetchContracts(this.#state.info.contractsUrl), {
+          txHash: this.#seed.input.txHash,
+          outputIndex: this.#seed.input.outputIndex,
+        });
     const mintScript = cache.mint();
     const stateScript = cache.state();
     const infoScript = cache.immutableInfo();
     const spendLock = cache.spendLock();
     const unit = cache.unit();
-    const recipient = this.#ownerAddress ? this.#ownerAddress : await this.#lucid.wallet.address();
-
-    // Declare minimum managment token assets here may add royalties depending on builder config
-    const stateValidatorAssets = { [unit.state]: 1n };
-    const infoValidatorAssets = { [unit.info]: 1n };
-    const recipientAssets = { [unit.owner]: 1n };
-    const assets = { ...stateValidatorAssets, ...infoValidatorAssets, ...recipientAssets };
+    const recipient = this.#ownerAddress ? this.#ownerAddress : await this.#mesh.wallet?.getChangeAddress();
+    if (!recipient) {
+      throw new Error('Must either call ownerAddress(address) or have a wallet selected.');
+    }
 
     const redeemer = Data.to(
       {
@@ -231,15 +236,24 @@ export class GenesisTxBuilder {
     );
 
     // Start building tx
-    const tx = this.#lucid.newTx().attachMintingPolicy(mintScript.script).collectFrom([this.#seed]);
+    const tx = newTxBuilder(this.#mesh);
+    tx.changeAddress(await this.#mesh.wallet.getChangeAddress());
+    tx.txIn(this.#seed.input.txHash, this.#seed.input.outputIndex, this.#seed.output.amount, this.#seed.output.address);
+
+    // Mint the three management tokens under the seed-parameterized minting policy
+    for (const mintUnit of [unit.state, unit.info, unit.owner]) {
+      const assetName = mintUnit.slice(mintScript.policyId.length);
+      tx.mintPlutusScript(mintScript.script.version)
+        .mint('1', mintScript.policyId, assetName)
+        .mintingScript(mintScript.script.code)
+        .mintRedeemerValue(redeemer, 'CBOR');
+    }
 
     // Add royalties to minted assets, if they are included
     const royalties = Object.values(this.#royalties);
     if (royalties.length > 0) {
-      const royaltyAddress = this.#royaltyValidatorAddress
-        ? this.#royaltyValidatorAddress
-        : await spendLock.address
-      addCip102RoyaltyToTransaction(tx, mintScript.policyId, royaltyAddress, royalties, redeemer);
+      const royaltyAddress = this.#royaltyValidatorAddress ? this.#royaltyValidatorAddress : spendLock.address;
+      addCip102RoyaltyToTransaction(tx, mintScript, royaltyAddress, royalties, redeemer);
     }
 
     // Add CIP-88 metadata to transaction if flag is set
@@ -249,7 +263,7 @@ export class GenesisTxBuilder {
         cip102Royalties: royalties,
       };
 
-      addCip88MetadataToTransaction(this.#lucid, tx, mintScript.script, unit.owner, config);
+      addCip88MetadataToTransaction(this.#mesh, tx, mintScript.script, unit.owner, config);
     }
 
     // Set the address to send the reference half of the token to
@@ -272,28 +286,17 @@ export class GenesisTxBuilder {
     const infoData = asChainCollectionInfo(this.#info);
     const infoDatum = Data.to(infoData, CollectionInfoMetadataShape);
 
-    tx.mintAssets(assets, redeemer)
-      .payToAddressWithData(
-        stateScript.address,
-        {
-          inline: genesisStateDatum,
-        },
-        stateValidatorAssets
-      )
-      .payToAddressWithData(
-        infoScript.address,
-        {
-          inline: infoDatum,
-        },
-        infoValidatorAssets
-      )
-      .payToAddress(recipient, recipientAssets);
+    tx.txOut(stateScript.address, [{ unit: unit.state, quantity: '1' }])
+      .txOutInlineDatumValue(genesisStateDatum, 'CBOR')
+      .txOut(infoScript.address, [{ unit: unit.info, quantity: '1' }])
+      .txOutInlineDatumValue(infoDatum, 'CBOR')
+      .txOut(recipient, [{ unit: unit.owner, quantity: '1' }]);
 
-    const state = toCollectionState(this.#lucid, genesisStateData);
+    const state = toCollectionState(genesisStateData, networkId(this.#mesh));
     return { cache, tx, state, recipient };
   }
 
-  static create(lucid: Lucid) {
-    return new GenesisTxBuilder(lucid);
+  static create(mesh: MeshContext) {
+    return new GenesisTxBuilder(mesh);
   }
 }
diff --git a/offchain/src/index.ts b/offchain/src/index.ts
index 8863c93..a7e7770 100644
--- a/offchain/src/index.ts
+++ b/offchain/src/index.ts
@@ -8,6 +8,7 @@ export * from './common';
 export * from './contract';
 export * from './genesis';
 export * from './image';
+export * from './mesh';
 export * from './mint';
 export * from './nft';
 export * from './royalty';
diff --git a/offchain/src/mesh.ts b/offchain/src/mesh.ts
new file mode 100644
index 0000000..1332784
--- /dev/null
+++ b/offchain/src/mesh.ts
@@ -0,0 +1,79 @@
+/// Lucid bundled a provider, wallet, and network together on a single `Lucid` instance that was
+/// threaded through the whole library. Mesh splits those into separate concerns, so this module
+/// provides a small composite standing in for that single instance across the rest of the package.
+import {
+  MeshTxBuilder,
+  SLOT_CONFIG_NETWORK,
+  unixTimeToEnclosingSlot,
+  type IEvaluator,
+  type IFetcher,
+  type ISubmitter,
+  type Network,
+  type UTxO,
+} from '@meshsdk/core';
+
+export type MeshProvider = IFetcher & ISubmitter & IEvaluator;
+
+/// Minimal surface shared by BrowserWallet and MeshWallet that this library relies on.
+export type MeshSignerWallet = {
+  getUtxos(): Promise<UTxO[]>;
+  getChangeAddress(): Promise<string>;
+  getCollateral(): Promise<UTxO[]>;
+  getRewardAddresses(): Promise<string[]>;
+  getUsedAddresses(): Promise<string[]>;
+  signTx(unsignedTx: string, partialSign?: boolean): Promise<string>;
+  signData(payload: string, address?: string): Promise<{ signature: string; key: string }>;
+  submitTx(tx: string): Promise<string>;
+};
+
+export type MeshContext = {
+  provider: MeshProvider;
+  wallet?: MeshSignerWallet;
+  network: Network;
+};
+
+/// 0 for any testnet, 1 for mainnet -- the numeric form several address/script serialization functions expect.
+export function networkId(mesh: MeshContext): 0 | 1 {
+  return mesh.network === 'mainnet' ? 1 : 0;
+}
+
+export function newTxBuilder(mesh: MeshContext) {
+  return new MeshTxBuilder({ fetcher: mesh.provider, submitter: mesh.provider, evaluator: mesh.provider });
+}
+
+/// Converts a unix timestamp in milliseconds into the slot number for the context's network.
+export function unixTimeToSlot(mesh: MeshContext, unixTimeMs: number): number {
+  return unixTimeToEnclosingSlot(unixTimeMs, SLOT_CONFIG_NETWORK[mesh.network]);
+}
+
+/// Finds the (assumed unique) UTxO currently holding an asset unit, searching the whole chain rather
+/// than a known address. Mirrors lucid-cardano's `lucid.utxoByUnit`, which Mesh has no direct equivalent
+/// for -- it resolves the holder address first, then fetches the UTxO at that address.
+export async function fetchUtxoByUnit(provider: MeshProvider, unit: string): Promise<UTxO | undefined> {
+  const holders = await provider.fetchAssetAddresses(unit);
+  if (holders.length === 0) {
+    return undefined;
+  }
+
+  const utxos = await provider.fetchAddressUTxOs(holders[0].address, unit);
+  return utxos[0];
+}
+
+/// Polls until a transaction is visible to the provider, mirroring lucid-cardano's `lucid.awaitTx`.
+export async function awaitTx(
+  provider: MeshProvider,
+  txHash: string,
+  checkIntervalMs = 3000,
+  maxAttempts = 40
+): Promise<boolean> {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      await provider.fetchTxInfo(txHash);
+      return true;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, checkIntervalMs));
+    }
+  }
+
+  return false;
+}
diff --git a/offchain/src/mint.test.ts b/offchain/src/mint.test.ts
index c16f3bc..56fe0dc 100644
--- a/offchain/src/mint.test.ts
+++ b/offchain/src/mint.test.ts
@@ -5,17 +5,24 @@ import { GenesisTxBuilder } from './genesis';
 import { MintTxBuilder } from './mint';
 import { fetchNftReferenceUtxos, toNftData } from './nft';
 import { fetchContracts, ScriptCache } from './script';
-import { applyScriptRefTx, applyTx, createEmulatorLucid, generateNft } from './support.test';
+import { applyScriptRefTx, applyTx, createEmulatorContext, generateNft } from './support.test';
 
 export async function genesis() {
-  const { lucid, emulator, seedUtxo, accounts } = await createEmulatorLucid();
+  const { mesh, emulator, seedUtxo, accounts } = await createEmulatorContext();
+
+  if (!mesh.wallet) {
+    throw new Error('Test context must have a wallet selected');
+  }
 
   // Use different address than selected wallet (account 0)
   const endMs = Date.now() + 10_000_000;
   const groupPolicyId = 'de2340edc45629456bf695200e8ea32f948a653b21ada10bc6f0c554';
   const contracts = await fetchContracts('local');
-  const cache = ScriptCache.cold(lucid, contracts, seedUtxo);
-  const { tx } = await GenesisTxBuilder.create(lucid)
+  const cache = ScriptCache.cold(mesh, contracts, {
+    txHash: seedUtxo.input.txHash,
+    outputIndex: seedUtxo.input.outputIndex,
+  });
+  const { tx } = await GenesisTxBuilder.create(mesh)
     .seed(seedUtxo)
     .group(groupPolicyId)
     .cache(cache)
@@ -23,19 +30,19 @@ export async function genesis() {
     .mintWindow(0, endMs)
     .useImmutableNftValidator()
     .royaltyValidatorAddress(cache.spendLock().address)
-    .ownerAddress(await lucid.wallet.address())
+    .ownerAddress(await mesh.wallet.getChangeAddress())
     .info(TEST_COLLECTION_INFO)
     .useCip88(true)
     .royalty(accounts[0].address, 4.3)
     .build();
 
-  const { ownerUtxo, stateUtxo, state } = await applyTx(lucid, tx, cache);
+  const { ownerUtxo, stateUtxo, state } = await applyTx(mesh, tx, cache);
 
-  const { mintScriptReferenceUtxo, stateScriptReferenceUtxo } = await applyScriptRefTx(lucid, cache);
+  const { mintScriptReferenceUtxo, stateScriptReferenceUtxo } = await applyScriptRefTx(mesh, cache);
 
   return {
     cache,
-    lucid,
+    mesh,
     emulator,
     accounts,
     stateUtxo,
@@ -49,8 +56,7 @@ export async function genesis() {
 test('Mint a token', async () => {
   const {
     cache,
-    lucid,
-    emulator,
+    mesh,
     stateUtxo,
     state: genesisState,
     mintScriptReferenceUtxo,
@@ -68,11 +74,11 @@ test('Mint a token', async () => {
     nfts.push(generateNft());
   }
 
-  const { tx } = await MintTxBuilder.create(lucid)
+  const { tx } = await MintTxBuilder.create(mesh)
     .cache(cache)
     .stateUtxo(stateUtxo)
-    .validFrom(emulator.now())
-    .validTo(emulator.now() + 10_000)
+    .validFrom(Date.now())
+    .validTo(Date.now() + 10_000)
     .mintingPolicyReferenceUtxo(mintScriptReferenceUtxo)
     .stateValidatorReferenceUtxo(stateScriptReferenceUtxo)
     .state(genesisState)
@@ -80,14 +86,14 @@ test('Mint a token', async () => {
     .nfts(nfts)
     .build();
 
-  const { state } = await applyTx(lucid, tx, cache);
+  const { state } = await applyTx(mesh, tx, cache);
   expect(state.nfts).toEqual(NUM_MINTS);
   expect(state.nextSequence).toEqual(NUM_MINTS);
 
-  const utxos = await fetchNftReferenceUtxos(lucid, cache.mint().policyId, cache.immutableNft().address);
+  const utxos = await fetchNftReferenceUtxos(mesh, cache.mint().policyId, cache.immutableNft().address);
   expect(utxos.length === NUM_MINTS);
 
-  const chainNft = await toNftData(lucid, utxos[0]);
+  const chainNft = await toNftData(utxos[0]);
   const orignalNft = nfts.find((nft) => nft.name === chainNft.name);
 
   expect(orignalNft).toEqual(chainNft);
diff --git a/offchain/src/mint.ts b/offchain/src/mint.ts
index 6eab9b2..c72f24f 100644
--- a/offchain/src/mint.ts
+++ b/offchain/src/mint.ts
@@ -1,4 +1,4 @@
-import { type Address, type Assets, type Lucid, type UTxO } from 'lucid-cardano';
+import type { MeshTxBuilder, UTxO } from '@meshsdk/core';
 
 import { NftMetadataWrappedShape } from './cip-68';
 import { toRoyaltyUnit } from './cip-102';
@@ -18,6 +18,7 @@ import {
   StateValidatorRedeemerShape,
 } from './contract';
 import { Data } from './data';
+import { fetchUtxoByUnit, networkId, newTxBuilder, unixTimeToSlot, type MeshContext } from './mesh';
 import { AddressedNft, MintunNft, prepareAssets } from './nft';
 import { fetchStateUtxo, ScriptCache } from './script';
 
@@ -25,10 +26,10 @@ import { fetchStateUtxo, ScriptCache } from './script';
 export const CIP_25_METADATA_LABEL = 721;
 
 export class MintTxBuilder {
-  #lucid: Lucid;
+  #mesh: MeshContext;
   #mintingPolicyId?: string;
   #cache?: ScriptCache;
-  #recipient?: Address;
+  #recipient?: string;
   #stateUtxo?: UTxO;
   #mintingPolicyReferenceUtxo?: UTxO;
   #stateValidatorReferenceUtxo?: UTxO;
@@ -38,8 +39,8 @@ export class MintTxBuilder {
   #validTo?: number;
   #useCip25 = false;
 
-  private constructor(lucid: Lucid) {
-    this.#lucid = lucid;
+  private constructor(mesh: MeshContext) {
+    this.#mesh = mesh;
   }
 
   mintingPolicyId(mintingPolicyId: string) {
@@ -52,7 +53,7 @@ export class MintTxBuilder {
     return this;
   }
 
-  recipient(recipient: Address) {
+  recipient(recipient: string) {
     this.#recipient = recipient;
     return this;
   }
@@ -108,19 +109,23 @@ export class MintTxBuilder {
     return this;
   }
 
-  async build() {
+  async build(): Promise<{ tx: MeshTxBuilder; cache: ScriptCache; state: CollectionState }> {
     const numMints = this.#nfts.length;
     if (numMints === 0) {
       throw new Error('Cannot build a mint transaction with no NFTs to mint');
     }
 
+    if (!this.#mesh.wallet) {
+      throw new Error('Must have a wallet selected to build a transaction.');
+    }
+
     if (!this.#cache) {
       if (this.#stateUtxo) {
-        const { state, cache } = await ScriptCache.fromStateUtxo(this.#lucid, this.#stateUtxo);
+        const { state, cache } = await ScriptCache.fromStateUtxo(this.#mesh, this.#stateUtxo);
         this.#cache = cache;
         this.#currentState = state;
       } else if (this.#mintingPolicyId) {
-        const { state, cache } = await ScriptCache.fromMintPolicyId(this.#lucid, this.#mintingPolicyId);
+        const { state, cache } = await ScriptCache.fromMintPolicyId(this.#mesh, this.#mintingPolicyId);
         this.#cache = cache;
         this.#currentState = state;
       } else {
@@ -145,7 +150,7 @@ export class MintTxBuilder {
     let hasRoyalty;
     try {
       const royaltyUnit = toRoyaltyUnit(this.#mintingPolicyId);
-      const royaltyFindResult = await this.#lucid.utxoByUnit(royaltyUnit);
+      const royaltyFindResult = await fetchUtxoByUnit(this.#mesh.provider, royaltyUnit);
       hasRoyalty = royaltyFindResult !== undefined;
     } catch {
       hasRoyalty = false;
@@ -154,8 +159,11 @@ export class MintTxBuilder {
     // Compute the updated state
     const currentState = this.#currentState
       ? this.#currentState
-      : await extractCollectionState(this.#lucid, this.#stateUtxo);
-    const recipientAddress = this.#recipient || (await this.#lucid.wallet.address());
+      : await extractCollectionState(this.#stateUtxo, networkId(this.#mesh));
+    const recipientAddress = this.#recipient || (await this.#mesh.wallet?.getChangeAddress());
+    if (!recipientAddress) {
+      throw new Error('Must either call recipient(address) or have a wallet selected.');
+    }
     const nftValidatorAddress = currentState.info.nftValidatorAddress;
 
     // Get script references if the state indicates there is a policy
@@ -188,63 +196,73 @@ export class MintTxBuilder {
     const validatorRedeemer = Data.to('EndpointMint', StateValidatorRedeemerShape);
 
     const ownerUnit = toOwnerUnit(this.#mintingPolicyId);
-    const ownerAsset = { [ownerUnit]: 1n };
     const stateUnit = toStateUnit(this.#mintingPolicyId);
-    const stateAsset = { [stateUnit]: 1n };
-    const stateOutput = { inline: Data.to(chainState, CollectionStateMetadataShape) };
+    const stateOutputDatum = Data.to(chainState, CollectionStateMetadataShape);
+
+    const tx = newTxBuilder(this.#mesh);
+    tx.changeAddress(await this.#mesh.wallet.getChangeAddress());
+    const mintScript = this.#cache.mint();
+    const stateScript = this.#cache.state();
 
-    const tx = this.#lucid.newTx();
+    // Spend the state utxo (script-guarded input holding an inline datum)
+    tx.txIn(
+      this.#stateUtxo.input.txHash,
+      this.#stateUtxo.input.outputIndex,
+      this.#stateUtxo.output.amount,
+      this.#stateUtxo.output.address
+    ).txInInlineDatumPresent();
 
     if (this.#stateValidatorReferenceUtxo) {
-      tx.readFrom([this.#stateValidatorReferenceUtxo]);
+      tx.spendingTxInReference(
+        this.#stateValidatorReferenceUtxo.input.txHash,
+        this.#stateValidatorReferenceUtxo.input.outputIndex
+      );
     } else {
-      tx.attachSpendingValidator(this.#cache.state().script);
+      tx.txInScript(stateScript.script.code);
     }
+    tx.txInRedeemerValue(validatorRedeemer, 'CBOR');
 
-    tx.collectFrom([this.#stateUtxo], validatorRedeemer);
+    // Mint the user and reference tokens for every NFT being minted
+    for (const asset of [...prepared.userMints, ...prepared.referenceMints]) {
+      const assetName = asset.unit.slice(this.#mintingPolicyId.length);
+      tx.mintPlutusScript(mintScript.script.version).mint(asset.quantity, this.#mintingPolicyId, assetName);
 
-    if (this.#mintingPolicyReferenceUtxo) {
-      tx.readFrom([this.#mintingPolicyReferenceUtxo]);
-    } else {
-      tx.attachMintingPolicy(this.#cache.mint().script);
+      if (this.#mintingPolicyReferenceUtxo) {
+        tx.mintTxInReference(
+          this.#mintingPolicyReferenceUtxo.input.txHash,
+          this.#mintingPolicyReferenceUtxo.input.outputIndex
+        );
+      } else {
+        tx.mintingScript(mintScript.script.code);
+      }
+      tx.mintRedeemerValue(mintRedeemer, 'CBOR');
     }
 
     // Force a validity range but allow override to keep from creating infinite validity transaction
-    if (this.#validFrom) {
-      tx.validFrom(this.#validFrom);
-    } else {
-      tx.validFrom(Date.now() - 500_000_000);
-    }
-
-    if (this.#validTo) {
-      tx.validTo(this.#validTo);
-    } else {
-      tx.validTo(Date.now() + 600_000);
-    }
+    const validFrom = this.#validFrom ? this.#validFrom : Date.now() - 500_000_000;
+    const validTo = this.#validTo ? this.#validTo : Date.now() + 600_000;
+    tx.invalidBefore(unixTimeToSlot(this.#mesh, validFrom)).invalidHereafter(unixTimeToSlot(this.#mesh, validTo));
 
     // TODO: Maybe enforce this just goes back to the original utxo address to prevent accidentally sending this to some other wallet
-    tx.mintAssets(prepared.userMints, mintRedeemer)
-      .mintAssets(prepared.referenceMints, mintRedeemer)
-      .payToAddress(recipientAddress, ownerAsset)
-      .payToAddressWithData(this.#cache.state().address, stateOutput, stateAsset);
+    tx.txOut(recipientAddress, [{ unit: ownerUnit, quantity: '1' }])
+      .txOut(stateScript.address, [{ unit: stateUnit, quantity: '1' }])
+      .txOutInlineDatumValue(stateOutputDatum, 'CBOR');
 
     for (const payout of prepared.referencePayouts) {
       // TODO: Add flag so can choose to inline or not
-      const outputData = { inline: Data.to(payout.chainData, NftMetadataWrappedShape) };
-      const referenceaAsset = { [payout.unit]: 1n };
-      tx.payToAddressWithData(payout.address, outputData, referenceaAsset);
+      const outputDatum = Data.to(payout.chainData, NftMetadataWrappedShape);
+      tx.txOut(payout.address, [{ unit: payout.unit, quantity: '1' }]).txOutInlineDatumValue(outputDatum, 'CBOR');
     }
 
     for (const [address, units] of Object.entries(prepared.userPayouts)) {
-      const assets: Assets = {};
-      for (const unit of units) {
-        assets[unit] = 1n;
-      }
-      tx.payToAddress(address, assets);
+      tx.txOut(
+        address,
+        units.map((unit) => ({ unit, quantity: '1' }))
+      );
     }
 
     if (this.#useCip25) {
-      tx.attachMetadata(CIP_25_METADATA_LABEL, prepared.cip25Metadata);
+      tx.metadataValue(CIP_25_METADATA_LABEL, prepared.cip25Metadata);
     }
 
     // Clear the state utxos because it will be spent when this transaction is submitted
@@ -256,7 +274,7 @@ export class MintTxBuilder {
     return { tx, cache: this.#cache, state: nextState };
   }
 
-  static create(lucid: Lucid) {
-    return new MintTxBuilder(lucid);
+  static create(mesh: MeshContext) {
+    return new MintTxBuilder(mesh);
   }
 }
diff --git a/offchain/src/nft.ts b/offchain/src/nft.ts
index 983f331..06b682d 100644
--- a/offchain/src/nft.ts
+++ b/offchain/src/nft.ts
@@ -1,4 +1,4 @@
-import { fromText, Lucid, toLabel, UTxO, type Address, type Assets } from 'lucid-cardano';
+import { stringToHex, type Asset, type UTxO } from '@meshsdk/core';
 
 import {
   createReferenceData,
@@ -12,7 +12,8 @@ import { COLLECTION_TOKEN_PURPOSE, toNftReferenceAssetName, toNftUserAssetName,
 import { TxMetadataPrimitive } from './common';
 import { Data } from './data';
 import { IMAGE_PURPOSE, ImageDimension, ImagePurpose } from './image';
-import { chunk, removeEmpty } from './utils';
+import type { MeshContext } from './mesh';
+import { chunk, removeEmpty, toLabel } from './utils';
 
 // Expands on CIP-25/68 File with dimension and purpose fields
 type MintunFile = {
@@ -59,9 +60,9 @@ type UserPayouts = {
 type Cip25Metadata = Record<string, MintunNft>;
 
 type PreparedAssets = {
-  userMints: Assets;
+  userMints: Asset[];
   userPayouts: UserPayouts;
-  referenceMints: Assets;
+  referenceMints: Asset[];
   referencePayouts: ReferencePayout[];
   cip25Metadata: Cip25Metadata;
 };
@@ -144,12 +145,12 @@ function asChainNftData(nft: MintunNft) {
   return Data.castFrom<NftMetadataType>(Data.fromJson(metadata), NftMetadataShape);
 }
 
-export async function fetchNftReferenceUtxos(lucid: Lucid, policyId: string, address: string) {
-  const addressUtxos = await lucid.utxosAt(address);
+export async function fetchNftReferenceUtxos(mesh: MeshContext, policyId: string, address: string) {
+  const addressUtxos = await mesh.provider.fetchAddressUTxOs(address);
   const unit = `${policyId}${toLabel(REFERENCE_TOKEN_LABEL)}${toPurposeHex(COLLECTION_TOKEN_PURPOSE.NFT)}`;
   const utxos = [];
   for (const utxo of addressUtxos) {
-    if (Object.keys(utxo.assets).find((asset) => asset.startsWith(unit))) {
+    if (utxo.output.amount.find((asset) => asset.unit.startsWith(unit))) {
       utxos.push(utxo);
     }
   }
@@ -157,8 +158,12 @@ export async function fetchNftReferenceUtxos(lucid: Lucid, policyId: string, add
   return utxos;
 }
 
-export async function toNftData(lucid: Lucid, utxo: UTxO): Promise<MintunNft> {
-  const { metadata } = await lucid.datumOf(utxo, NftMetadataWrappedShape);
+export async function toNftData(utxo: UTxO): Promise<MintunNft> {
+  if (!utxo.output.plutusData) {
+    throw new Error('UTxO does not have an inline datum to decode NFT metadata from.');
+  }
+
+  const { metadata } = Data.from(utxo.output.plutusData, NftMetadataWrappedShape);
   const nft = Data.toJson(metadata) as MintunChainNft;
   const description = Array.isArray(nft.description) ? nft.description.join('') : undefined;
   const files = nft.files ? nft.files.map((file) => ({ ...file, src: file.src.join('') })) : [];
@@ -171,19 +176,19 @@ export function prepareAssets(
   nfts: AddressedNft[],
   policyId: string,
   sequence: number,
-  defaultRecipientAddress: Address,
+  defaultRecipientAddress: string,
   hasRoyalty: boolean,
-  nftValidatorAddress?: Address
+  nftValidatorAddress?: string
 ): PreparedAssets {
-  const userMints: Assets = {};
+  const userMints: Asset[] = [];
   const userPayouts: UserPayouts = {};
-  const referenceMints: Assets = {};
+  const referenceMints: Asset[] = [];
   const cip25Metadata: Cip25Metadata = {};
   const referencePayouts: ReferencePayout[] = [];
   let extra: Data = '';
   if (hasRoyalty) {
     extra = new Map<string, Data>();
-    extra.set(fromText('royalty_included'), 1n);
+    extra.set(stringToHex('royalty_included'), 1n);
   }
 
   for (const nft of nfts) {
@@ -198,11 +203,11 @@ export function prepareAssets(
     const referencePayoutAddress = nftValidatorAddress ? nftValidatorAddress : recipientAdress;
     const userPayout = userPayouts[recipientAdress] || [];
 
-    userMints[userUnit] = 1n;
+    userMints.push({ unit: userUnit, quantity: '1' });
     userPayout.push(userUnit);
     userPayouts[recipientAdress] = userPayout;
 
-    referenceMints[referenceUnit] = 1n;
+    referenceMints.push({ unit: referenceUnit, quantity: '1' });
     referencePayouts.push({ unit: referenceUnit, address: referencePayoutAddress, chainData });
     cip25Metadata[userAssetName] = metadata;
 
diff --git a/offchain/src/script.ts b/offchain/src/script.ts
index 2ed6e97..6fa1a7a 100644
--- a/offchain/src/script.ts
+++ b/offchain/src/script.ts
@@ -1,7 +1,7 @@
 /// Allow passing in as little or as much already computed data as possible
 /// This cache will be updated if a some part is missing. The only case where
 
-import { applyDoubleCborEncoding, Lucid, UTxO, type Credential, type Script } from 'lucid-cardano';
+import { applyCborEncoding, resolveScriptHash, serializePlutusScript, type PlutusScript, type UTxO } from '@meshsdk/core';
 
 import { toInfoUnit, toOwnerUnit } from './collection';
 import { extractCollectionState, toStateUnit } from './collection-state';
@@ -15,6 +15,7 @@ import {
   parameterizeSpendLockValidator,
   parameterizeStateValidator,
 } from './contract';
+import { fetchUtxoByUnit, networkId, type MeshContext } from './mesh';
 import { findUtxo, TxReference } from './utils';
 
 /// A loose definition of the contracts json structure.
@@ -35,9 +36,8 @@ export type Contracts = {
 /// All the parts commonly used when dealing with a paramaterized script
 export type ScriptInfo = {
   name: string;
-  script: Script;
+  script: PlutusScript;
   policyId: string;
-  credential: Credential;
   address: string;
 };
 
@@ -83,21 +83,19 @@ export function getScript(contracts: Contracts, title: string) {
 }
 
 /// Utility function for grabbing commonly needed information about a validator (or minting policy)
-export function getScriptInfo(lucid: Lucid, name: string, paramaterizedScript: string): ScriptInfo {
-  const script: Script = {
-    type: 'PlutusV2',
-    script: applyDoubleCborEncoding(paramaterizedScript),
+export function getScriptInfo(mesh: MeshContext, name: string, paramaterizedScript: string): ScriptInfo {
+  const script: PlutusScript = {
+    version: 'V2',
+    code: applyCborEncoding(paramaterizedScript),
   };
 
-  const policyId = lucid.utils.validatorToScriptHash(script);
-  const credential = lucid.utils.scriptHashToCredential(policyId);
-  const address = lucid.utils.credentialToAddress(credential);
+  const policyId = resolveScriptHash(script.code, script.version);
+  const address = serializePlutusScript(script, undefined, networkId(mesh)).address;
 
   return {
     name,
     script,
     policyId,
-    credential,
     address,
   };
 }
@@ -112,7 +110,7 @@ export type ScriptCacheWarmer = {
 /// Cache holds all the computed data from a builder transaction to
 /// allow subsequent transactions to reuse computed data
 export class ScriptCache {
-  #lucid: Lucid;
+  #mesh: MeshContext;
   #contracts: Contracts;
   #seed: TxReference;
   #mint?: ScriptInfo;
@@ -126,18 +124,18 @@ export class ScriptCache {
   #delegateMint?: ScriptInfo;
   #unit?: ManageUnitLookup;
 
-  private constructor(lucid: Lucid, contracts: Contracts, seed: TxReference) {
-    this.#lucid = lucid;
+  private constructor(mesh: MeshContext, contracts: Contracts, seed: TxReference) {
+    this.#mesh = mesh;
     this.#seed = seed;
     this.#contracts = contracts;
   }
 
-  static cold(lucid: Lucid, contracts: Contracts, seed: TxReference) {
-    return new ScriptCache(lucid, contracts, seed);
+  static cold(mesh: MeshContext, contracts: Contracts, seed: TxReference) {
+    return new ScriptCache(mesh, contracts, seed);
   }
 
-  static warm(lucid: Lucid, seed: TxReference, warmer: ScriptCacheWarmer) {
-    const cache = new ScriptCache(lucid, warmer.contracts, seed);
+  static warm(mesh: MeshContext, seed: TxReference, warmer: ScriptCacheWarmer) {
+    const cache = new ScriptCache(mesh, warmer.contracts, seed);
     cache.#mint = warmer.mint;
     cache.#state = warmer.state;
     cache.#unit = warmer.unit;
@@ -146,19 +144,22 @@ export class ScriptCache {
   }
 
   // Utility for when you already know the minting policy id
-  static async fromMintPolicyId(lucid: Lucid, policyId: string) {
-    const stateUtxo = await lucid.utxoByUnit(toStateUnit(policyId));
+  static async fromMintPolicyId(mesh: MeshContext, policyId: string) {
+    const stateUtxo = await fetchUtxoByUnit(mesh.provider, toStateUnit(policyId));
+    if (!stateUtxo) {
+      throw new Error(`Could not find state utxo for minting policy id: ${policyId}`);
+    }
 
-    return ScriptCache.fromStateUtxo(lucid, stateUtxo);
+    return ScriptCache.fromStateUtxo(mesh, stateUtxo);
   }
 
   // Utility for when you already have a state utxo
-  static async fromStateUtxo(lucid: Lucid, stateUtxo: UTxO) {
-    const state = await extractCollectionState(lucid, stateUtxo);
+  static async fromStateUtxo(mesh: MeshContext, stateUtxo: UTxO) {
+    const state = await extractCollectionState(stateUtxo, networkId(mesh));
 
     const contracts = await fetchContracts(state.info.contractsUrl);
 
-    const cache = ScriptCache.cold(lucid, contracts, {
+    const cache = ScriptCache.cold(mesh, contracts, {
       txHash: state.info.seed.hash,
       outputIndex: state.info.seed.index,
     });
@@ -166,8 +167,8 @@ export class ScriptCache {
     return { state, cache };
   }
 
-  static copy(lucid: Lucid, cache: ScriptCache) {
-    const copy = new ScriptCache(lucid, cache.#contracts, cache.#seed);
+  static copy(mesh: MeshContext, cache: ScriptCache) {
+    const copy = new ScriptCache(mesh, cache.#contracts, cache.#seed);
     copy.#mint = cache.#mint;
     copy.#state = cache.#state;
     copy.#unit = cache.#unit;
@@ -175,8 +176,8 @@ export class ScriptCache {
     return copy;
   }
 
-  lucid() {
-    return this.#lucid;
+  mesh() {
+    return this.#mesh;
   }
 
   contractsUrl() {
@@ -186,7 +187,7 @@ export class ScriptCache {
   mint() {
     if (!this.#mint) {
       const { txHash, outputIndex } = this.#seed;
-      this.#mint = parameterizeMintingPolicy(this.#lucid, this.#contracts, txHash, outputIndex);
+      this.#mint = parameterizeMintingPolicy(this.#mesh, this.#contracts, txHash, outputIndex);
     }
 
     return this.#mint;
@@ -195,7 +196,7 @@ export class ScriptCache {
   spendLock() {
     if (!this.#spendLock) {
       const mint = this.mint();
-      this.#spendLock = parameterizeSpendLockValidator(this.#lucid, this.#contracts, mint.policyId);
+      this.#spendLock = parameterizeSpendLockValidator(this.#mesh, this.#contracts, mint.policyId);
     }
 
     return this.#spendLock;
@@ -204,7 +205,7 @@ export class ScriptCache {
   state() {
     if (!this.#state) {
       const mint = this.mint();
-      this.#state = parameterizeStateValidator(this.#lucid, this.#contracts, mint.policyId);
+      this.#state = parameterizeStateValidator(this.#mesh, this.#contracts, mint.policyId);
     }
 
     return this.#state;
@@ -214,7 +215,7 @@ export class ScriptCache {
   immutableInfo() {
     if (!this.#immutableInfo) {
       const mint = this.mint();
-      this.#immutableInfo = parameterizeImmutableInfoValidator(this.#lucid, this.#contracts, mint.policyId);
+      this.#immutableInfo = parameterizeImmutableInfoValidator(this.#mesh, this.#contracts, mint.policyId);
     }
 
     return this.#immutableInfo;
@@ -223,7 +224,7 @@ export class ScriptCache {
   immutableNft() {
     if (!this.#immutableNft) {
       const mint = this.mint();
-      this.#immutableNft = parameterizeImmutableNftValidator(this.#lucid, this.#contracts, mint.policyId);
+      this.#immutableNft = parameterizeImmutableNftValidator(this.#mesh, this.#contracts, mint.policyId);
     }
 
     return this.#immutableNft;
@@ -232,7 +233,7 @@ export class ScriptCache {
   permissiveNft() {
     if (!this.#permissiveNft) {
       const mint = this.mint();
-      this.#permissiveNft = parameterizePermissiveNftValidator(this.#lucid, this.#contracts, mint.policyId);
+      this.#permissiveNft = parameterizePermissiveNftValidator(this.#mesh, this.#contracts, mint.policyId);
     }
 
     return this.#permissiveNft;
@@ -241,7 +242,7 @@ export class ScriptCache {
   derivativeMint() {
     if (!this.#derivativeMint) {
       const mint = this.mint();
-      this.#derivativeMint = parameterizeDerivativeMintingPolicy(this.#lucid, this.#contracts, mint.policyId);
+      this.#derivativeMint = parameterizeDerivativeMintingPolicy(this.#mesh, this.#contracts, mint.policyId);
     }
 
     return this.#derivativeMint;
@@ -251,7 +252,7 @@ export class ScriptCache {
     if (!this.#delegateMint || this.#delegate !== delegate) {
       const mint = this.mint();
       this.#delegate = delegate;
-      this.#delegateMint = parameterizeDelegativeMintingPolicy(this.#lucid, this.#contracts, mint.policyId, delegate);
+      this.#delegateMint = parameterizeDelegativeMintingPolicy(this.#mesh, this.#contracts, mint.policyId, delegate);
     }
 
     return this.#delegateMint;
@@ -271,24 +272,23 @@ export class ScriptCache {
   }
 }
 
-export async function fetchUtxo(lucid: Lucid, address: string, unit: string) {
-  const utxos = await lucid.utxosAt(address);
-  const utxo = utxos.find((utxo) => utxo.assets[unit]);
-  return utxo;
+export async function fetchUtxo(mesh: MeshContext, address: string, unit: string) {
+  const utxos = await mesh.provider.fetchAddressUTxOs(address, unit);
+  return utxos[0];
 }
 
 /// Fetches the UTxO that holds the state token
 export async function fetchStateUtxo(cache: ScriptCache) {
-  return await fetchUtxo(cache.lucid(), cache.state().address, cache.unit().state);
+  return await fetchUtxo(cache.mesh(), cache.state().address, cache.unit().state);
 }
 
 /// Fetches the UTxO that holds the collection info token
 export async function fetchInfoUtxo(cache: ScriptCache) {
-  return await fetchUtxo(cache.lucid(), cache.immutableInfo().address, cache.unit().info);
+  return await fetchUtxo(cache.mesh(), cache.immutableInfo().address, cache.unit().info);
 }
 
 /// Fetches the UTxO that holds the collection owner token.
 export async function fetchOwnerUtxo(cache: ScriptCache) {
   const unit = cache.unit();
-  return await findUtxo(cache.lucid(), unit.owner);
+  return await findUtxo(cache.mesh(), unit.owner);
 }
diff --git a/offchain/src/support.test.ts b/offchain/src/support.test.ts
index 1a8799f..ed85915 100644
--- a/offchain/src/support.test.ts
+++ b/offchain/src/support.test.ts
@@ -1,4 +1,5 @@
-import { Emulator, generateSeedPhrase, type Assets, type Lucid, type Tx } from 'lucid-cardano';
+import { generateMnemonic, MeshWallet, SLOT_CONFIG_NETWORK, type Asset, type MeshTxBuilder, type UTxO } from '@meshsdk/core';
+import { ScalusEmulator } from '@meshsdk/scalus-emulator';
 import { expect } from 'vitest';
 
 import { extractCollectionInfo } from './collection-info';
@@ -9,59 +10,85 @@ import {
   fetchMintingPolicyReferenceUtxo,
   fetchStateValidatorReferenceUtxo,
 } from './contract';
+import { awaitTx, networkId, type MeshContext } from './mesh';
 import { MintunNft } from './nft';
 import { fetchInfoUtxo, fetchOwnerUtxo, fetchStateUtxo, ScriptCache } from './script';
 import { submit } from './utils';
 
-/// Creates a new emulator account with the given assets, if any.
-export async function generateEmulatorAccount(lucid: Lucid, assets: Assets = {}) {
-  const seedPhrase = generateSeedPhrase();
+const TEST_NETWORK = 'preview';
+
+let seedCounter = 0;
+/// Emulator seed utxos need distinct, real-looking (64 hex char) tx hashes.
+function fakeTxHash(): string {
+  seedCounter += 1;
+  return seedCounter.toString(16).padStart(64, '0');
+}
 
-  lucid.selectWalletFromSeed(seedPhrase);
-  const address = await lucid.wallet.address();
+/// Derives a fresh emulator account (mnemonic + address) without a fetcher/submitter attached yet --
+/// mirrors lucid-cardano's ability to derive an address from a seed phrase with no provider.
+async function deriveEmulatorAccount() {
+  const words = generateMnemonic().split(' ');
+  const wallet = new MeshWallet({ networkId: 0, key: { type: 'mnemonic', words } });
+  await wallet.init();
+  const address = await wallet.getChangeAddress();
+  return { words, address };
+}
 
+/// Creates a new emulator account with the given assets, if any.
+export async function generateEmulatorAccount(assets: Asset[] = []) {
+  const { words, address } = await deriveEmulatorAccount();
   return {
-    seedPhrase,
+    words,
     address,
     assets,
   };
 }
 
-/// Instantiates an instace of Lucid with an Emulator as the provider.  The emulator is seeded with two starting accounts with one of them preselected.
-export async function createEmulatorLucid() {
-  const { Lucid } = await import('lucid-cardano');
+/// Instantiates a MeshContext backed by the Scalus emulator. The emulator is seeded with two starting
+/// accounts with one of them preselected as the context's wallet.
+export async function createEmulatorContext() {
+  const ACCOUNT_0 = await generateEmulatorAccount([{ unit: 'lovelace', quantity: '7500000000000' }]);
+  const ACCOUNT_1 = await generateEmulatorAccount([{ unit: 'lovelace', quantity: '100000000' }]);
+  const ACCOUNT_2 = await generateEmulatorAccount([{ unit: 'lovelace', quantity: '10000000' }]);
+  const ACCOUNT_3 = await generateEmulatorAccount([{ unit: 'lovelace', quantity: '10000000' }]);
+
+  const initialUtxos: UTxO[] = [ACCOUNT_0, ACCOUNT_1].map((account) => ({
+    input: { txHash: fakeTxHash(), outputIndex: 0 },
+    output: { address: account.address, amount: account.assets },
+  }));
 
-  const customLucid = await Lucid.new(undefined, 'Custom');
+  const emulator = new ScalusEmulator(initialUtxos, SLOT_CONFIG_NETWORK[TEST_NETWORK]);
 
-  const ACCOUNT_0 = await generateEmulatorAccount(customLucid, { lovelace: 7_500_0000_000n });
-  const ACCOUNT_1 = await generateEmulatorAccount(customLucid, { lovelace: 100_000_000n });
-  const ACCOUNT_2 = await generateEmulatorAccount(customLucid, { lovelace: 10_000_000n });
-  const ACCOUNT_3 = await generateEmulatorAccount(customLucid, { lovelace: 10_000_000n });
+  const wallet = new MeshWallet({
+    networkId: 0,
+    fetcher: emulator,
+    submitter: emulator,
+    key: { type: 'mnemonic', words: ACCOUNT_0.words },
+  });
+  await wallet.init();
 
-  const emulator = new Emulator([ACCOUNT_0, ACCOUNT_1]);
-  const lucid = await Lucid.new(emulator);
-  lucid.selectWalletFromSeed(ACCOUNT_0.seedPhrase);
+  const mesh: MeshContext = { provider: emulator, wallet, network: TEST_NETWORK };
 
-  const utxos = await lucid.wallet.getUtxos();
+  const utxos = await wallet.getUtxos();
   expect(utxos.length > 0, 'Wallet must have at least one UTXO for this test');
   const seedUtxo = utxos[0];
 
   return {
-    lucid,
+    mesh,
     emulator,
     accounts: [ACCOUNT_0, ACCOUNT_1, ACCOUNT_2, ACCOUNT_3],
     seedUtxo,
   };
 }
 
-export async function applyScriptRefTx(lucid: Lucid, cache: ScriptCache) {
-  const mintReferenceTx = await createMintingPolicyReference(lucid, cache);
-  const mintReferenceTxHash = await submit(mintReferenceTx);
-  await lucid.awaitTx(mintReferenceTxHash);
+export async function applyScriptRefTx(mesh: MeshContext, cache: ScriptCache) {
+  const mintReferenceTx = await createMintingPolicyReference(mesh, cache);
+  const mintReferenceTxHash = await submit(mesh, mintReferenceTx);
+  await awaitTx(mesh.provider, mintReferenceTxHash);
 
-  const stateReferenceTx = await createStateValidatorReference(lucid, cache);
-  const stateReferenceTxHash = await submit(stateReferenceTx);
-  await lucid.awaitTx(stateReferenceTxHash);
+  const stateReferenceTx = await createStateValidatorReference(mesh, cache);
+  const stateReferenceTxHash = await submit(mesh, stateReferenceTx);
+  await awaitTx(mesh.provider, stateReferenceTxHash);
 
   // Use cache utils to check to tokens were distributed as expected
   const mintScriptReferenceUtxo = await fetchMintingPolicyReferenceUtxo(cache);
@@ -80,9 +107,9 @@ export async function applyScriptRefTx(lucid: Lucid, cache: ScriptCache) {
   };
 }
 
-export async function applyTx(lucid: Lucid, tx: Tx, cache: ScriptCache) {
-  const txHash = await submit(tx);
-  await lucid.awaitTx(txHash);
+export async function applyTx(mesh: MeshContext, tx: MeshTxBuilder, cache: ScriptCache) {
+  const txHash = await submit(mesh, tx);
+  await awaitTx(mesh.provider, txHash);
 
   // Use cache utils to check to tokens were distributed as expected
   const stateUtxo = await fetchStateUtxo(cache);
@@ -96,8 +123,8 @@ export async function applyTx(lucid: Lucid, tx: Tx, cache: ScriptCache) {
 
   // NOTE: Typescript won't detect that the vitest expect will terminate the
   //       function early so we use ! to manually indicate that is the case
-  const state = await extractCollectionState(lucid, stateUtxo!);
-  const info = await extractCollectionInfo(lucid, infoUtxo!);
+  const state = await extractCollectionState(stateUtxo!, networkId(mesh));
+  const info = await extractCollectionInfo(infoUtxo!);
 
   return { txHash, stateUtxo: stateUtxo!, ownerUtxo: ownerUtxo!, infoUtxo: infoUtxo!, state, info };
 }
diff --git a/offchain/src/utils.ts b/offchain/src/utils.ts
index 8834f5f..d022690 100644
--- a/offchain/src/utils.ts
+++ b/offchain/src/utils.ts
@@ -1,4 +1,6 @@
-import { fromText, toText, type Lucid, type Tx, type Unit, type UTxO } from 'lucid-cardano';
+import { hexToBytes, hexToString, stringToHex, type MeshTxBuilder, type UTxO } from '@meshsdk/core';
+
+import { fetchUtxoByUnit, type MeshContext } from './mesh';
 
 /// Simple form of UTxO that only includes part needed to reference a transaction
 export type TxReference = {
@@ -7,32 +9,39 @@ export type TxReference = {
 };
 
 /// Utility function for completing a transaction, signing it, and then submitting it.
-export async function submit(tx: Tx) {
-  const completed = await tx.complete();
-  const signed = await completed.sign().complete();
-  return await signed.submit();
+export async function submit(mesh: MeshContext, builder: MeshTxBuilder) {
+  if (!mesh.wallet) {
+    throw new Error('No wallet selected.');
+  }
+
+  // Lucid derived the change address from the connected wallet automatically; Mesh requires it be
+  // set explicitly before completing the transaction so it can run UTxO selection.
+  builder.changeAddress(await mesh.wallet.getChangeAddress());
+  const unsignedTx = await builder.complete();
+  const signedTx = await mesh.wallet.signTx(unsignedTx);
+  return await mesh.wallet.submitTx(signedTx);
 }
 
 /// Result of trying to find a UTxO.
-/// wallet is false if the UTxO was not found in the selected lucid wallet.
+/// wallet is false if the UTxO was not found in the selected wallet.
 export type UtxoFindResult = {
   utxo?: UTxO;
   wallet: boolean;
 };
 
 /// Utility function to find a utxo first in wallet then in general if no match was found
-export async function findUtxo(lucid: Lucid, unit: Unit): Promise<UtxoFindResult> {
+export async function findUtxo(mesh: MeshContext, unit: string): Promise<UtxoFindResult> {
   // Normally should be in the wallet
   let utxo: UTxO | undefined = undefined;
   let wallet = false;
-  if (lucid.wallet) {
-    const utxos = await lucid.wallet.getUtxos();
-    utxo = utxos.find((utxo) => utxo.assets[unit]);
+  if (mesh.wallet) {
+    const utxos = await mesh.wallet.getUtxos();
+    utxo = utxos.find((utxo) => utxo.output.amount.some((asset) => asset.unit === unit));
   }
 
   // Wider net search but can't be spent from current wallet
   if (!utxo) {
-    utxo = await lucid.utxoByUnit(unit);
+    utxo = await fetchUtxoByUnit(mesh.provider, unit);
   } else {
     wallet = true;
   }
@@ -62,7 +71,7 @@ export function chunk(str: string, charactersPerChunk = 64, prefix = ''): string
 
 /// Utility function for encoding and splitting a UTF8 string into 64 byte chunks.
 export function asChunkedHex(utf8String: string, prefix = ''): string[] {
-  const hex = fromText(utf8String);
+  const hex = stringToHex(utf8String);
   const charactersPerChunk = 128;
   return chunk(hex, charactersPerChunk, prefix);
 }
@@ -70,9 +79,9 @@ export function asChunkedHex(utf8String: string, prefix = ''): string[] {
 /// Utility function for resting a chunked hex string to a single UTF8 string
 export function toJoinedText(hexStrings: string | string[]) {
   if (Array.isArray(hexStrings)) {
-    return toText(hexStrings.join(''));
+    return hexToString(hexStrings.join(''));
   } else {
-    return toText(hexStrings);
+    return hexToString(hexStrings);
   }
 }
 
@@ -108,3 +117,75 @@ export function removeEmpty(record: Record<string, unknown> | unknown[]) {
     }
   }
 }
+
+/// CIP-67 asset name label helpers. lucid-cardano shipped these; Mesh does not, so reimplemented here
+/// against the CIP-67 spec (CRC-8/SMBUS checksum of the 2-byte label, framed as `0<label><checksum>0`).
+function crc8(data: Uint8Array): number {
+  let crc = 0;
+  for (const byte of data) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) {
+      crc = crc & 0x80 ? ((crc << 1) ^ 0x07) & 0xff : (crc << 1) & 0xff;
+    }
+  }
+  return crc;
+}
+
+function labelChecksum(numHex: string): string {
+  return crc8(hexToBytes(numHex)).toString(16).padStart(2, '0');
+}
+
+/// Converts a CIP-67 label number into its 8-character hex prefix (e.g. `000643b0` for label 100).
+export function toLabel(num: number): string {
+  if (num < 0 || num > 65535) {
+    throw new Error(`Label ${num} out of range: min label 0 - max label 65535.`);
+  }
+
+  const numHex = num.toString(16).padStart(4, '0');
+  return `0${numHex}${labelChecksum(numHex)}0`;
+}
+
+/// Extracts the CIP-67 label number from an 8-character hex prefix, or null if it isn't a valid label.
+export function fromLabel(label: string): number | null {
+  if (label.length !== 8 || !(label[0] === '0' && label[7] === '0')) {
+    return null;
+  }
+
+  const numHex = label.slice(1, 5);
+  const num = parseInt(numHex, 16);
+  const check = label.slice(5, 7);
+
+  return check === labelChecksum(numHex) ? num : null;
+}
+
+/// Builds an asset unit (policyId + optional CIP-67 label + optional hex name).
+export function toUnit(policyId: string, name?: string | null, label?: number | null): string {
+  const hexLabel = label ? toLabel(label) : '';
+  const n = name ? name : '';
+  if ((n + hexLabel).length > 64) {
+    throw new Error('Asset name size exceeds 32 bytes.');
+  }
+  if (policyId.length !== 56) {
+    throw new Error('Policy id invalid: must be a 28 byte hex string.');
+  }
+
+  return policyId + hexLabel + n;
+}
+
+/// Splits an asset unit into its policy id, full asset name, label-stripped name, and CIP-67 label.
+export function fromUnit(unit: string): {
+  policyId: string;
+  assetName: string | null;
+  name: string | null;
+  label: number | null;
+} {
+  const policyId = unit.slice(0, 56);
+  const assetName = unit.slice(56) || null;
+  const label = fromLabel(unit.slice(56, 64));
+  const name = (() => {
+    const hexName = label !== null ? unit.slice(64) : unit.slice(56);
+    return hexName || null;
+  })();
+
+  return { policyId, assetName, name, label };
+}
diff --git a/offchain/vitest.config.ts b/offchain/vitest.config.ts
index d7a9d2e..0942cb9 100644
--- a/offchain/vitest.config.ts
+++ b/offchain/vitest.config.ts
@@ -1,10 +1,15 @@
-import { defineConfig } from 'vitest/config';
+import { configDefaults, defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
-    exclude: [
-      'src/support.test.ts',
-      'src/fixtures.test.ts',
-    ],
+    exclude: [...configDefaults.exclude, 'src/support.test.ts', 'src/fixtures.test.ts'],
+    server: {
+      deps: {
+        // `scalus` (a dependency of @meshsdk/scalus-emulator) is CommonJS; Vite must process it
+        // through its transform pipeline rather than loading it via Node's native ESM loader,
+        // which fails to synthesize named exports from a CJS module.
+        inline: [/scalus/],
+      },
+    },
   },
 });
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3971e6c..98ff5cb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -22,17 +22,20 @@ importers:
         version: 0.5.11(@ianvs/prettier-plugin-sort-imports@4.1.1(prettier@3.2.5))(prettier@3.2.5)
       vercel:
         specifier: ^33.6.2
-        version: 33.6.2(@swc/core@1.4.17(@swc/helpers@0.5.2))(encoding@0.1.13)
+        version: 33.6.2(@swc/core@1.4.17)(encoding@0.1.13)
 
   offchain:
     dependencies:
+      '@meshsdk/core':
+        specifier: ^1.9.1
+        version: 1.9.1(@bufbuild/protobuf@1.10.1)(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
       '@sinclair/typebox':
         specifier: ^0.32.27
         version: 0.32.27
-      lucid-cardano:
-        specifier: ^0.10.10
-        version: 0.10.10
     devDependencies:
+      '@meshsdk/scalus-emulator':
+        specifier: ^1.9.1
+        version: 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
       '@parcel/packager-ts':
         specifier: 2.12.0
         version: 2.12.0(@parcel/core@2.12.0(@swc/helpers@0.5.2))
@@ -71,13 +74,16 @@ importers:
         version: 3.4.0
       '@mdx-js/loader':
         specifier: ^3.0.1
-        version: 3.0.1(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2)))
+        version: 3.0.1(webpack@5.90.3(@swc/core@1.4.17))
       '@mdx-js/react':
         specifier: ^3.0.1
         version: 3.0.1(@types/react@18.3.1)(react@18.3.1)
+      '@meshsdk/core':
+        specifier: ^1.9.1
+        version: 1.9.1(@bufbuild/protobuf@1.10.1)(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
       '@next/mdx':
         specifier: ^14.1.3
-        version: 14.1.3(@mdx-js/loader@3.0.1(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2))))(@mdx-js/react@3.0.1(@types/react@18.3.1)(react@18.3.1))
+        version: 14.1.3(@mdx-js/loader@3.0.1(webpack@5.90.3(@swc/core@1.4.17)))(@mdx-js/react@3.0.1(@types/react@18.3.1)(react@18.3.1))
       '@peculiar/webcrypto':
         specifier: ^1.4.6
         version: 1.4.6
@@ -150,9 +156,6 @@ importers:
       date-fns:
         specifier: ^3.6.0
         version: 3.6.0
-      lucid-cardano:
-        specifier: ^0.10.10
-        version: 0.10.10
       magic-bytes.js:
         specifier: ^1.10.0
         version: 1.10.0
@@ -194,7 +197,7 @@ importers:
         version: 2.3.0
       tailwindcss-animate:
         specifier: ^1.0.7
-        version: 1.0.7(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)))
+        version: 1.0.7(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)))
       uid:
         specifier: ^2.0.2
         version: 2.0.2
@@ -213,10 +216,10 @@ importers:
     devDependencies:
       '@tailwindcss/line-clamp':
         specifier: ^0.4.4
-        version: 0.4.4(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)))
+        version: 0.4.4(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)))
       '@tailwindcss/typography':
         specifier: ^0.5.13
-        version: 0.5.13(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)))
+        version: 0.5.13(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)))
       '@types/node':
         specifier: ^20.12.7
         version: 20.12.7
@@ -243,13 +246,13 @@ importers:
         version: 7.34.1(eslint@8.57.0)
       eslint-plugin-tailwindcss:
         specifier: ^3.15.1
-        version: 3.15.1(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)))
+        version: 3.15.1(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)))
       postcss:
         specifier: ^8.4.38
         version: 8.4.38
       tailwindcss:
         specifier: ^3.4.3
-        version: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))
+        version: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))
       typescript:
         specifier: ^5.4.5
         version: 5.4.5
@@ -363,10 +366,119 @@ packages:
     resolution: {integrity: sha512-dQjSq/7HaSjRM43FFGnv5keM2HsxpmyV1PfaSVm0nzzjwwTmjOe6J4bC8e3+pTEIgHaHj+1ZlLThRJ2auc/w1Q==}
     engines: {node: '>=6.9.0'}
 
+  '@biglup/is-cid@1.0.3':
+    resolution: {integrity: sha512-R0XPZ/IQhU2TtetSFI9vI+7kJOJYNiCncn5ixEBW+/LNaZCo2HK37Mq3pRNzrM4FryuAkyeqY7Ujmj3I3e3t9g==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  '@bufbuild/protobuf@1.10.1':
+    resolution: {integrity: sha512-wJ8ReQbHxsAfXhrf9ixl0aYbZorRuOWpBNzm8pL8ftmSxQx/wnJD5Eg861NwJU/czy2VXFIebCeZnZrI9rktIQ==}
+
+  '@cardano-ogmios/client@6.9.0':
+    resolution: {integrity: sha512-IsoUVsaMXiYyhWrdVKYOA5PDlX0EZ2gaq4lfk4JelRw6mcWVxemUrMaU2ndvugO9LQ3SCM1nESPgMIU0xe5FWw==}
+    engines: {node: '>=14'}
+
+  '@cardano-ogmios/schema@6.9.0':
+    resolution: {integrity: sha512-e7QVLF+dQMIv9p+p5CWQjMfBmkERYRa2wK2AjyehQZCJnecZ0gvTbRqewdX5VW4mVXf6KUfFyphsxWK46Pg6LA==}
+    engines: {node: '>=14'}
+
+  '@cardano-sdk/core@0.46.12':
+    resolution: {integrity: sha512-yUA/xBUQMiMqIWiZPvIhM911pL3jNKg4PkZQ8qP9R7yU3NQ5x4RQkZ+zFDlVLxUt+gJiwIW2es0iPd8ObIKCxA==}
+    engines: {node: '>=16.20.2'}
+    peerDependencies:
+      rxjs: ^7.4.0
+    peerDependenciesMeta:
+      rxjs:
+        optional: true
+
+  '@cardano-sdk/core@0.47.0':
+    resolution: {integrity: sha512-UANc6oY8Emjf5ID+Qk6XKxujPfrdxu0rDNDNy+jYJGMYh/kyUrLzOK8Ge4ydblqKQwohRXmMKagFusad3yHoDg==}
+    engines: {node: '>=22'}
+
+  '@cardano-sdk/crypto@0.4.5':
+    resolution: {integrity: sha512-ymliqxdmen5dGVaiMVQ0VnhrwaYUjbPD3sHoMj8NI6MTuxrREp3pLJASREtWhwmv9k+QzDT6CoyuIXnlEQiWZQ==}
+    engines: {node: '>=16.20.2'}
+    peerDependencies:
+      '@dcspark/cardano-multiplatform-lib-asmjs': ^3.1.1
+      '@dcspark/cardano-multiplatform-lib-browser': ^3.1.1
+      '@dcspark/cardano-multiplatform-lib-nodejs': ^3.1.1
+    peerDependenciesMeta:
+      '@dcspark/cardano-multiplatform-lib-asmjs':
+        optional: true
+      '@dcspark/cardano-multiplatform-lib-browser':
+        optional: true
+      '@dcspark/cardano-multiplatform-lib-nodejs':
+        optional: true
+
+  '@cardano-sdk/crypto@0.4.7':
+    resolution: {integrity: sha512-4aCsLOkqaIS/gSGw4SBqNGcCIp6hZ8alQWJx58U/OiOxC43t7i2JpKagdyWfCNekPM14hO7BWER7y31wf4BFxw==}
+    engines: {node: '>=22'}
+    peerDependencies:
+      '@dcspark/cardano-multiplatform-lib-asmjs': ^3.1.1
+      '@dcspark/cardano-multiplatform-lib-browser': ^3.1.1
+      '@dcspark/cardano-multiplatform-lib-nodejs': ^3.1.1
+    peerDependenciesMeta:
+      '@dcspark/cardano-multiplatform-lib-asmjs':
+        optional: true
+      '@dcspark/cardano-multiplatform-lib-browser':
+        optional: true
+      '@dcspark/cardano-multiplatform-lib-nodejs':
+        optional: true
+
+  '@cardano-sdk/dapp-connector@0.13.30':
+    resolution: {integrity: sha512-42BZ4imKWInPbUjUEJ/B4EjHyr0qL60nrcx7OposNaTIOGJtY26+J43n6A4I3Qx7WQhzYNg0tYIznhJTjiVmLg==}
+    engines: {node: '>=22'}
+
+  '@cardano-sdk/input-selection@0.14.28':
+    resolution: {integrity: sha512-pbysJUaIbbpesbv/f0XfFPKBb+bLjCmPcMfNJzpePSZBvr8bUcFpnfKtq28KthVdpe2mgL3k9ebTTcBSk7aERw==}
+    engines: {node: '>=16.20.2'}
+
+  '@cardano-sdk/key-management@0.29.18':
+    resolution: {integrity: sha512-5flm1jQwLJj5dKh5WYxFgifAPcTFZ7lwLAY0Ys0WZ+25Dfp3b/4z0JH9d1OmtteIEX8O7rccQ3eEu1p1cUcl0g==}
+    engines: {node: '>=22'}
+
+  '@cardano-sdk/util@0.17.1':
+    resolution: {integrity: sha512-TCYe+wRguW1WgRlbWqhGPhcSBkzVzdIcCVgDDN7wiQk2dew0EWVqjsKeqDZdfwzy/s2kr/ZOgXIGywBn/Bzu/Q==}
+    engines: {node: '>=16.20.2'}
+
+  '@cardano-sdk/util@0.17.2':
+    resolution: {integrity: sha512-LdY33OQG5H4p0rppHtjnM+akc1poKhz+02T9zsXsbShfTbeU9HXlA0nJ8xj9FNZMs+ozDR0HWrUjDc7fkNZI7w==}
+    engines: {node: '>=22'}
+
+  '@cardanosolutions/json-bigint@1.1.0':
+    resolution: {integrity: sha512-Pdgz18cSwLKKgheOqW/dqbzNI+CliNT4AdaKaKY/P++J9qLxIB8MITCurlzbaFWV3W4nmK0CRQwI1yvuArmjFg==}
+
+  '@chainsafe/is-ip@2.1.0':
+    resolution: {integrity: sha512-KIjt+6IfysQ4GCv66xihEitBjvhU/bixbbbFxdJ1sqCp4uJ0wuZiYBPhksZoy4lfaF0k9cwNzY5upEW/VWdw3w==}
+
+  '@chainsafe/netmask@2.0.0':
+    resolution: {integrity: sha512-I3Z+6SWUoaljh3TBzCnCxjlUyN8tA+NAk5L6m9IxvCf1BENQTePzPMis97CoN/iMW1St3WN+AWCCRp+TTBRiDg==}
+
+  '@connectrpc/connect-node@1.4.0':
+    resolution: {integrity: sha512-0ANnrr6SvsjevsWEgdzHy7BaHkluZyS6s4xNoVt7RBHFR5V/kT9lPokoIbYUOU9JHzdRgTaS3x5595mwUsu15g==}
+    engines: {node: '>=16.0.0'}
+    peerDependencies:
+      '@bufbuild/protobuf': ^1.4.2
+      '@connectrpc/connect': 1.4.0
+
+  '@connectrpc/connect-web@1.4.0':
+    resolution: {integrity: sha512-13aO4psFbbm7rdOFGV0De2Za64DY/acMspgloDlcOKzLPPs0yZkhp1OOzAQeiAIr7BM/VOHIA3p8mF0inxCYTA==}
+    peerDependencies:
+      '@bufbuild/protobuf': ^1.4.2
+      '@connectrpc/connect': 1.4.0
+
+  '@connectrpc/connect@1.4.0':
+    resolution: {integrity: sha512-vZeOkKaAjyV4+RH3+rJZIfDFJAfr+7fyYr6sLDKbYX3uuTVszhFe9/YKf5DNqrDb5cKdKVlYkGn6DTDqMitAnA==}
+    peerDependencies:
+      '@bufbuild/protobuf': ^1.4.2
+
   '@cspotcode/source-map-support@0.8.1':
     resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
 
+  '@dnsquery/dns-packet@6.1.1':
+    resolution: {integrity: sha512-WXTuFvL3G+74SchFAtz3FgIYVOe196ycvGsMgvSH/8Goptb1qpIQtIuM4SOK9G9lhMWYpHxnXyy544ZhluFOew==}
+    engines: {node: '>=6'}
+
   '@edge-runtime/format@2.2.1':
     resolution: {integrity: sha512-JQTRVuiusQLNNLe2W9tnzBlV/GvSVcozLl4XZHk5swnRZ/v6jp8TqR8P7sqmJsQqblDZ3EztcWmLDbhRje/+8g==}
     engines: {node: '>=16'}
@@ -390,6 +502,9 @@ packages:
   '@emnapi/runtime@1.1.1':
     resolution: {integrity: sha512-3bfqkzuR1KLx57nZfjr2NLnFOobvyS0aTszaEGCGqmYMVDRaGvgIZbjGSV/MHSSmLgQ/b9JFHQ5xm5WRZYd+XQ==}
 
+  '@emurgo/cardano-message-signing-nodejs@1.1.0':
+    resolution: {integrity: sha512-PQRc8K8wZshEdmQenNUzVtiI8oJNF/1uAnBhidee5C4o1l2mDLOW+ur46HWHIFKQ6x8mSJTllcjMscHgzju0gQ==}
+
   '@esbuild/aix-ppc64@0.19.12':
     resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==}
     engines: {node: '>=12'}
@@ -565,6 +680,51 @@ packages:
   '@floating-ui/utils@0.2.1':
     resolution: {integrity: sha512-9TANp6GPoMtYzQdt54kfAyMmz1+osLlXdg2ENroU7zzrtflTLrrC/lgrIfaSe+Wu0b89GKccT7vxXA0MoAIO+Q==}
 
+  '@foxglove/crc@0.0.3':
+    resolution: {integrity: sha512-DjIZsnL3CyP/yQ/vUYA9cjrD0a/8YXejI5ZmsaOiT16cLfZcTwaCxIN01/ys4jsy+dZCQ/9DnWFn7AEFbiMDaA==}
+
+  '@harmoniclabs/bigint-utils@1.0.0':
+    resolution: {integrity: sha512-OhZMHcdtH2hHKMlxWFHf71PmKHdoi9ARpjS9mUu0/cd8VWDDjT7VQoQwC5NN/68iyO4O5Dojrvrp9tjG5BDABA==}
+
+  '@harmoniclabs/biguint@1.0.0':
+    resolution: {integrity: sha512-5DyCIBDL4W+7ffR1IJSbGrCG4xEYxAlFH5gCNF42qtyL5ltwZ92Ae1MyXpHM2TUPy7ocSTqlLUsOdy+SvqVVPw==}
+
+  '@harmoniclabs/bitstream@1.0.0':
+    resolution: {integrity: sha512-Ed/I46IuCiytE5QiMmmUo9kPJcypM7OuUqoRaAXUALL5C6LKLpT6kYE1qeuhLkx2/WvkHT18jcOX6jhM/nmqoA==}
+
+  '@harmoniclabs/bytestring@1.0.0':
+    resolution: {integrity: sha512-d5m10O0okKc6QNX0pSRriFTkk/kNMnMBGbo5X3kEZwKaXTI4tDVoTZBL7bwbYHwOEdSxWJjVtlO9xtB7ZrYZNg==}
+
+  '@harmoniclabs/cbor@1.6.0':
+    resolution: {integrity: sha512-KI25p8pHI1rmFZC9NYSxATwlCZ+KJdjydpptKebHcw03Iy7M+E8mF+hSnN5dTbS45xw5ZyKUgPLRgLo1sTuIoQ==}
+
+  '@harmoniclabs/crypto@0.2.5':
+    resolution: {integrity: sha512-t2saWMFWBx8tOHotiYTTfQKhPGpWT4AMLXxq3u0apShVXNV0vgL0gEgSMudBjES/wrKByCqa2xmU70gadz26hA==}
+
+  '@harmoniclabs/obj-utils@1.0.0':
+    resolution: {integrity: sha512-EO1bQBZAORrutcP+leP5YNDwNd/9TOE23VEvs3ktniXg6w0knUrLjUIl2Pkcbs/D1VQxqmsNpXho+vaMj00qxA==}
+
+  '@harmoniclabs/pair@1.0.0':
+    resolution: {integrity: sha512-D9OBowsUsy1LctHxWzd9AngTzoo5x3rBiJ0gu579t41Q23pb+VNx1euEfluUEiaYbgljcl1lb/4D1fFTZd1tRQ==}
+
+  '@harmoniclabs/plutus-data@1.2.6':
+    resolution: {integrity: sha512-rF046GZ07XDpjZBNybALKYSycjxCLzXKbhLylu9pRuZiii5fVXReEfgtLB29TsPBvGY6ZBeiyHgJnLgm+huZBw==}
+    peerDependencies:
+      '@harmoniclabs/bytestring': ^1.0.0
+      '@harmoniclabs/cbor': ^1.3.0
+
+  '@harmoniclabs/uint8array-utils@1.0.4':
+    resolution: {integrity: sha512-Z454prSbX4geXGHyjjcn9vm6u9NsD3VJykv8f8yE1VjIXSPitaLPEnm8u2+B+GMp1chYlLilOq+kW4OvJ6y28A==}
+
+  '@harmoniclabs/uplc@1.4.1':
+    resolution: {integrity: sha512-sELKStjxPBPBxBMylU4oBSUe0/8eJe2HqRblNSwrMu8Fso4YpSPDqHZ33iDZ8QAadVUsT5r2EQKX0TLrj7qXvQ==}
+    peerDependencies:
+      '@harmoniclabs/bytestring': ^1.0.0
+      '@harmoniclabs/cbor': ^1.3.0
+      '@harmoniclabs/crypto': ^0.3.0-dev0
+      '@harmoniclabs/pair': ^1.0.0
+      '@harmoniclabs/plutus-data': ^1.2.4
+
   '@hookform/error-message@2.0.1':
     resolution: {integrity: sha512-U410sAr92xgxT1idlu9WWOVjndxLdgPUHEB8Schr27C9eh7/xUnITWpCMF93s+lGiG++D4JnbSnrb5A21AdSNg==}
     peerDependencies:
@@ -766,12 +926,18 @@ packages:
   '@jridgewell/trace-mapping@0.3.9':
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
 
+  '@leichtgewicht/ip-codec@2.0.5':
+    resolution: {integrity: sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==}
+
   '@lezer/common@1.2.1':
     resolution: {integrity: sha512-yemX0ZD2xS/73llMZIK6KplkjIjf2EvAHcinDi/TfJ9hS25G0388+ClHt6/3but0oOxinTcQHJLDXh6w1crzFQ==}
 
   '@lezer/lr@1.4.0':
     resolution: {integrity: sha512-Wst46p51km8gH0ZUmeNrtpRYmdlRHUpN1DQd3GFAyKANi8WVz8c2jHYTf1CVScFaCjQw1iO3ZZdqGDxQPRErTg==}
 
+  '@libp2p/interface@3.2.5':
+    resolution: {integrity: sha512-RdTchTdakBBc4ShKKsvoME/bJYsrCoVDpdYQVdd4TQ30TCb8QwWKGClqAtw7gfLNuaUKm41xz06kASW6AZpbDA==}
+
   '@lmdb/lmdb-darwin-arm64@2.8.5':
     resolution: {integrity: sha512-KPDeVScZgA1oq0CiPBcOa3kHIqU+pTOwRFDIhxvmf8CTNvqdZQYp5cCKW0bUk69VygB2PuTiINFWbY78aR2pQw==}
     cpu: [arm64]
@@ -824,6 +990,33 @@ packages:
       '@types/react': '>=16'
       react: '>=16'
 
+  '@meshsdk/common@1.9.0-beta.100':
+    resolution: {integrity: sha512-H3ktKR9eheRKZupg7DLdUr8A9dsefJbu7Wc+I1suwrv+oAZWiJ2wCuF3bX2QQo3LyWrSkVCE7WEiKFfQmukIww==}
+
+  '@meshsdk/common@1.9.1':
+    resolution: {integrity: sha512-66l7vcY+h9w71auVaE7RLJYs87DmO+JTEmQ2xknd6F8fAcR73nMxLZunMRbygPoV9gHDBTMYfHoMBZqWt7N6EA==}
+
+  '@meshsdk/core-cst@1.9.0-beta.100':
+    resolution: {integrity: sha512-gXC7c81puzv12C3xJ6vhH/KIEc/P6ScuXsgmLlqFMpDv0SuoMg+42HgdyWi0WrccVwi8cdepsn5YhtCaYVn0nw==}
+
+  '@meshsdk/core-cst@1.9.1':
+    resolution: {integrity: sha512-1e72mtTehjV/XQWpxtnejhEXyhU1f8CWqoTaQfq2rfBydLJfFs/NDEYfBKBOx697MOWM7VPAHjLvVAENqS57EQ==}
+
+  '@meshsdk/core@1.9.1':
+    resolution: {integrity: sha512-khMrEkMU71t3kn6nHM8/5rjVry055jORdln+xegP0KpVzCjWxjOe+bzyCMnQehwNT7R8OEe7wx8zYUL4qTijkA==}
+
+  '@meshsdk/provider@1.9.0-beta.101':
+    resolution: {integrity: sha512-xbb0pCDpeHk8WEzgZCUlwy1CLpOPSPNn3TPtuLuMNnebCO8lZhvP3NYZqX/CUnTkOjXP4dxu5Zbf7ipZ43V4RQ==}
+
+  '@meshsdk/scalus-emulator@1.9.1':
+    resolution: {integrity: sha512-OQWtDTpgyrBDfXwT1wBhHPs6bRytndHUU+a/MISKVtkzRudi9lEVX8dEiTQkM8a3+a2cTUHAZpmudiDOTr7Jeg==}
+
+  '@meshsdk/transaction@1.9.1':
+    resolution: {integrity: sha512-FjKSoUi2xFaKJPI1ObQ13UkrCJu+iPW6THP//ZD/f5I1NciaUz3bcoQ7xWcc7El4TCcDunBPp9di6w9JitBR6Q==}
+
+  '@meshsdk/wallet@1.9.1':
+    resolution: {integrity: sha512-lPovMk86Ex6t1s12CiSJFfxnTM31vXxwB7h0BOnznPgueBts2z0cgvQVtBMlhIKHTmPWW1/gkuEH/5dGMfZ3jA==}
+
   '@mischnic/json-sourcemap@0.1.1':
     resolution: {integrity: sha512-iA7+tyVqfrATAIsIRWQG+a7ZLLD0VaOCKV2Wd/v4mqIU3J9c4jx9p7S0nw1XH3gJCKNBOOwACOPYYSUu9pgT+w==}
     engines: {node: '>=12.0.0'}
@@ -858,6 +1051,18 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@multiformats/dns@1.0.15':
+    resolution: {integrity: sha512-W0zAMABtAn+3chgFcPGvllKND7M6GblMAAFcJQTy+iMmGiyFErZYPzAh2b50Y3SFf340iFV7+ckVgZkGfUyxzA==}
+
+  '@multiformats/mafmt@12.1.6':
+    resolution: {integrity: sha512-tlJRfL21X+AKn9b5i5VnaTD6bNttpSpcqwKVmDmSHLwxoz97fAHaepqFOk/l1fIu94nImIXneNbhsJx/RQNIww==}
+
+  '@multiformats/multiaddr@12.5.1':
+    resolution: {integrity: sha512-+DDlr9LIRUS8KncI1TX/FfUn8F2dl6BIxJgshS/yFQCNB5IAF0OGzcwB39g5NLE22s4qqDePv0Qof6HdpJ/4aQ==}
+
+  '@multiformats/multiaddr@13.0.3':
+    resolution: {integrity: sha512-mEqqJ4r3a/uuFMTpRkU316wGNIDQNhuVWpm+ebKTQeYsfv9jXbPONWM6VVnj3KGUrwfsX7GZOyp4TFqEA2SPCw==}
+
   '@multiformats/murmur3@2.1.8':
     resolution: {integrity: sha512-6vId1C46ra3R1sbJUOFCZnsUIveR9oF20yhPmAFxPm0JfrX3/ZRCgP3YDrBzlGoEppOXnA9czHeYc0T9mB6hbA==}
     engines: {node: '>=16.0.0', npm: '>=7.0.0'}
@@ -1825,6 +2030,9 @@ packages:
   '@scure/bip39@1.2.2':
     resolution: {integrity: sha512-HYf9TUXG80beW+hGAt3TRM8wU6pQoYur9iNypTROm42dorCGmLnFe3eWjz3gOq6G62H2WRh0FCzAR1PI+29zIA==}
 
+  '@simplewebauthn/browser@13.3.0':
+    resolution: {integrity: sha512-BE/UWv6FOToAdVk0EokzkqQQDOWtNydYlY6+OrmiZ5SCNmb41VehttboTetUM3T/fr6EAFYVXjz4My2wg230rQ==}
+
   '@sinclair/typebox@0.25.24':
     resolution: {integrity: sha512-XJfwUVUKDHF5ugKwIcxEgc9k8b7HbznCp6eUfWgu710hMPNIO4aw4/zB5RogDQz8nd6gyCDpU9O/m6qYEWY6yQ==}
 
@@ -1963,6 +2171,9 @@ packages:
   '@types/acorn@4.0.6':
     resolution: {integrity: sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==}
 
+  '@types/base32-encoding@1.0.2':
+    resolution: {integrity: sha512-6kXiZ8gETqBU/B9ddcw15nwacX4iX9mLZTU0kghWK5u+OdjfJg6vxHh/vXoURWTyLSzs2jKgcq1lS3S/Tvl4mw==}
+
   '@types/chai-subset@1.3.5':
     resolution: {integrity: sha512-c2mPnw+xHtXDoHmdtcCXGwyLMiauiAyxWMzhGpqHC4nqI/Y5G2XhTampslK2rb59kpcuHon03UH8W6iYUzw88A==}
 
@@ -1987,6 +2198,9 @@ packages:
   '@types/hast@3.0.4':
     resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
 
+  '@types/json-bigint@1.0.4':
+    resolution: {integrity: sha512-ydHooXLbOmxBbubnA7Eh+RpBzuaIiQjh8WGJYQB50JFGFrdxW7JzVlyEV7fAXw0T2sqJ1ysTneJbiyNLqZRAag==}
+
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
 
@@ -2084,6 +2298,13 @@ packages:
   '@ungap/structured-clone@1.2.0':
     resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==}
 
+  '@utxorpc/sdk@0.6.8':
+    resolution: {integrity: sha512-Mff6q2o7R2aam85KmjtAZDKPhJesMmnGFbk2M54lPO0FwrrWRfUf6DYezqWfYcjXgKQSHDuklAcdtF0weEENRA==}
+
+  '@utxorpc/spec@0.16.0':
+    resolution: {integrity: sha512-EK2M0TBp14MrRCYDuFeJ+bAS39RxxLLh+CD08h/YvAgxSv/4ZOBCf1/sxHAGCBGGndB4heZYFeuQ+i1i8vP5lw==}
+    engines: {node: '>=20.0.0'}
+
   '@vercel/build-utils@7.10.0':
     resolution: {integrity: sha512-Lgt95xovRE/9ISevWiToDjt0l9NX8mlMUJKLQ6b7hjMB9ARkT3y+cgdx6TJJg4qmunIS8RKRxqTjzYXMPJLnmg==}
 
@@ -2237,14 +2458,21 @@ packages:
   '@xtuc/long@4.2.2':
     resolution: {integrity: sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==}
 
+  '@zxing/text-encoding@0.9.0':
+    resolution: {integrity: sha512-U/4aVJ2mxI0aDNI8Uq0wEhMgY+u4CNtEb0om3+y3+niDAsoTCOB33UF0sxpzqzdqXLqmvc+vZyAt4O8pPdfkwA==}
+
   abbrev@1.1.1:
     resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}
 
+  abort-error@1.0.2:
+    resolution: {integrity: sha512-lVgvB2NyPLqbXXhVmXcYFTC1x5K7CiVdPgdY7LGgFQWC8506oN01sPN3i9cl9ynuwF4iJ0TS9exnR7cZ9FuX4w==}
+
   abortcontroller-polyfill@1.7.5:
     resolution: {integrity: sha512-JMJ5soJWP18htbbxJjG7bG6yuI6pRhgJ0scHHTfkUjf6wjP912xZWvM+A4sJK3gqd9E8fcPbDnOefbA9Th/FIQ==}
 
   acorn-import-assertions@1.9.0:
     resolution: {integrity: sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==}
+    deprecated: package has been renamed to acorn-import-attributes
     peerDependencies:
       acorn: ^8
 
@@ -2430,6 +2658,9 @@ packages:
   asynciterator.prototype@1.0.0:
     resolution: {integrity: sha512-wwHYEIS0Q80f5mosx3L/dfG5t5rjEa9Ft51GTaNt862EnpyGHpgz2RkZvLPp1oF5TnAiTohkEKVEu8pQPJI7Vg==}
 
+  asynckit@0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+
   atomically@2.0.2:
     resolution: {integrity: sha512-Xfmb4q5QV7uqTlVdMSTtO5eF4DCHfNOdaPyKlbFShkzeNP+3lj3yjjcbdjSmEY4+pDBKJ9g26aP+ImTe88UHoQ==}
 
@@ -2452,9 +2683,20 @@ packages:
     resolution: {integrity: sha512-M0JtH+hlOL5pLQwHOLNYZaXuhqmvS8oExsqB1SBYgA4Dk7u/xx+YdGHXaK5pyUfed5mYXdlYiphWq3G8cRi5JQ==}
     engines: {node: '>=4'}
 
+  axios@1.19.0:
+    resolution: {integrity: sha512-ht/iuYZXEjFxLH/Hkezgd7m6JKlHHXEUSneaDz8uZe1Gj5QZtCnpyDsckvAiEnT89OEbCLmnte4R4sn7P0EKFw==}
+
   axobject-query@3.2.1:
     resolution: {integrity: sha512-jsyHu61e6N4Vbz/v18DHwWYKK0bSWLqn47eeDSKPB7m8tqMHF9YJ+mhIk2lVteyZrY8tnSj/jHOv4YiTCuCJgg==}
 
+  b4a@1.8.1:
+    resolution: {integrity: sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==}
+    peerDependencies:
+      react-native-b4a: '*'
+    peerDependenciesMeta:
+      react-native-b4a:
+        optional: true
+
   bail@2.0.2:
     resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
 
@@ -2464,6 +2706,9 @@ packages:
   base-x@3.0.9:
     resolution: {integrity: sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==}
 
+  base32-encoding@1.0.0:
+    resolution: {integrity: sha512-k1gA7f00ODLY7YtuEQFz0Kn3huTCmL/JW+oQtw51ID+zxs5chj/YQ1bXN+Q0JsqiKB2Yn0oA0AA8uipFYgpagQ==}
+
   base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
 
@@ -2474,6 +2719,9 @@ packages:
     resolution: {integrity: sha512-pX/cYW3dCa87Jrzv6DAr8ivbbJRzEX5yGhdt8IutnX/PCIXfpx+mabWNK/M8qqh+zQ0J3thftUBHW0ByuUlG0w==}
     engines: {node: '>=10.4.0'}
 
+  bignumber.js@9.3.1:
+    resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==}
+
   binary-extensions@2.2.0:
     resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==}
     engines: {node: '>=8'}
@@ -2481,6 +2729,21 @@ packages:
   bindings@1.5.0:
     resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
 
+  bip39@3.1.0:
+    resolution: {integrity: sha512-c9kiwdk45Do5GL0vJMe7tS95VjCii65mYAH7DfWl3uW8AVzXKQVUm64i3hzVybBDMp9r7j9iNxR85+ul8MdN/A==}
+
+  blake2b-wasm@2.4.0:
+    resolution: {integrity: sha512-S1kwmW2ZhZFFFOghcx73+ZajEfKBqhP82JMssxtLVMxlaPea1p9uoLiUZ5WYyHn0KddwbLc+0vh4wR0KBNoT5w==}
+
+  blake2b@2.1.4:
+    resolution: {integrity: sha512-AyBuuJNI64gIvwx13qiICz6H6hpmjvYS5DGkG6jbXMOT8Z3WUJ3V1X0FlhIoT1b/5JtHE3ki+xjtMvu1nn+t9A==}
+
+  blakejs@1.2.1:
+    resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==}
+
+  bn.js@5.2.5:
+    resolution: {integrity: sha512-Vq886eXykuP5E6HcKSSStP3bJgrE6In5WKxVUvJ8XGpWWYs2xZHWqUwzCtGgEtBcxyd57KBFDPFoUfNzdaHCNg==}
+
   boolbase@1.0.0:
     resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
 
@@ -2523,10 +2786,22 @@ packages:
     resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
     engines: {node: '>=8'}
 
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
   call-bind@1.0.7:
     resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==}
     engines: {node: '>= 0.4'}
 
+  call-bind@1.0.9:
+    resolution: {integrity: sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==}
+    engines: {node: '>= 0.4'}
+
+  call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+
   callsites@3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
@@ -2544,6 +2819,10 @@ packages:
   carstream@2.2.0:
     resolution: {integrity: sha512-/gHkK0lQjmGM45fhdx8JD+x7a1XS1qUk3T9xWWSt3oZiWPLq4u/lnDstp+N55K7hqTKKlb0CCr43EHTrlbmJSQ==}
 
+  cbor@10.0.12:
+    resolution: {integrity: sha512-exQDevYd7ZQLP4moMQcZkKCVZsXLAtUSflObr3xTh4xzFIv/xBCdvCd6L259kQOUP2kcTC0jvC6PpZIf/WmRXA==}
+    engines: {node: '>=20'}
+
   cborg@4.2.0:
     resolution: {integrity: sha512-q6cFW5m3KxfP/9xGI3yGLaC1l5DP6DWM9IvjiJojnIwohL5CQDl02EXViPV852mOfQo+7PJGPN01MI87vFGzyA==}
     hasBin: true
@@ -2551,6 +2830,12 @@ packages:
   ccount@2.0.1:
     resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
 
+  chacha-native@2.0.3:
+    resolution: {integrity: sha512-93h+osfjhR2sMHAaapTLlL/COoBPEZ6upicPBQ4GfUyadoMb8t9/M0PKK8kC+F+DEA/Oy3Kg9w3HzY3J1foP3g==}
+
+  chacha@2.1.0:
+    resolution: {integrity: sha512-FhVtqaZOiHlOKUkAWfDlJ+oe/O8iPQbCC0pFXJqphr4YQBCZPXa8Mv3j35+W4eWFWCoTUcW2u5IWDDkknygvVA==}
+
   chai@4.4.1:
     resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==}
     engines: {node: '>=4'}
@@ -2597,6 +2882,10 @@ packages:
     resolution: {integrity: sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==}
     engines: {node: '>=6.0'}
 
+  cipher-base@1.0.7:
+    resolution: {integrity: sha512-Mz9QMT5fJe7bKI7MH31UilT5cEK5EHHRCccw/YRFsRY47AuNgaV6HY3rscp0/I4Q+tTW/5zoqpSeRRI54TkDWA==}
+    engines: {node: '>= 0.10'}
+
   cjs-module-lexer@1.2.3:
     resolution: {integrity: sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==}
 
@@ -2648,6 +2937,10 @@ packages:
     resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==}
     engines: {node: '>=12.5.0'}
 
+  combined-stream@1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+
   comma-separated-tokens@2.0.3:
     resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
 
@@ -2683,6 +2976,9 @@ packages:
   convert-source-map@2.0.0:
     resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
 
+  core-util-is@1.0.3:
+    resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
+
   cosmiconfig@9.0.0:
     resolution: {integrity: sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==}
     engines: {node: '>=14'}
@@ -2692,9 +2988,18 @@ packages:
       typescript:
         optional: true
 
+  create-hash@1.2.0:
+    resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==}
+
+  create-hmac@1.1.7:
+    resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==}
+
   create-require@1.1.1:
     resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
 
+  cross-fetch@3.2.0:
+    resolution: {integrity: sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==}
+
   cross-spawn@7.0.3:
     resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
     engines: {node: '>= 8'}
@@ -2792,6 +3097,10 @@ packages:
     resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
     engines: {node: '>= 0.4'}
 
+  delayed-stream@1.0.0:
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
+
   delegates@1.0.0:
     resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==}
 
@@ -2847,6 +3156,9 @@ packages:
   dom-serializer@1.4.1:
     resolution: {integrity: sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==}
 
+  dom-walk@0.1.2:
+    resolution: {integrity: sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==}
+
   domelementtype@2.3.0:
     resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==}
 
@@ -2868,6 +3180,10 @@ packages:
     resolution: {integrity: sha512-M3NhsLbV1i6HuGzBUH8vXrtxOk+tWmzWKDMbAVSUp3Zsjm7ywFeuwrUXhmhQyRK1q5B5GGy7hcXPbj3bnfZg2g==}
     engines: {node: '>=6'}
 
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
   eastasianwidth@0.2.0:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
 
@@ -2938,6 +3254,10 @@ packages:
     resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==}
     engines: {node: '>= 0.4'}
 
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
   es-errors@1.3.0:
     resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
     engines: {node: '>= 0.4'}
@@ -2953,10 +3273,18 @@ packages:
     resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==}
     engines: {node: '>= 0.4'}
 
+  es-object-atoms@1.1.2:
+    resolution: {integrity: sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==}
+    engines: {node: '>= 0.4'}
+
   es-set-tostringtag@2.0.3:
     resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==}
     engines: {node: '>= 0.4'}
 
+  es-set-tostringtag@2.1.0:
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
+
   es-shim-unscopables@1.0.2:
     resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==}
 
@@ -3252,6 +3580,9 @@ packages:
     resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
     engines: {node: '>= 0.6'}
 
+  eventemitter3@5.0.4:
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
+
   events-intercept@2.0.0:
     resolution: {integrity: sha512-blk1va0zol9QOrdZt0rFXo5KMkNPVSp92Eju/Qz8THwKWKRKeE0T8Br/1aW6+Edkyq9xHYgYxn2QtOnUKPUp+Q==}
 
@@ -3318,17 +3649,37 @@ packages:
   flatted@3.3.1:
     resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==}
 
+  follow-redirects@1.16.0:
+    resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
   for-each@0.3.3:
     resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==}
 
+  for-each@0.3.5:
+    resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
+    engines: {node: '>= 0.4'}
+
   foreground-child@3.1.1:
     resolution: {integrity: sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==}
     engines: {node: '>=14'}
 
+  form-data@4.0.6:
+    resolution: {integrity: sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==}
+    engines: {node: '>= 6'}
+
   formdata-polyfill@4.0.10:
     resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==}
     engines: {node: '>=12.20.0'}
 
+  fraction.js@4.0.1:
+    resolution: {integrity: sha512-NQYzZw8MUsxSZFQo6E8tKOlmSd/BlDTNOR4puXFSHSwFwNaIlmbortQy5PDN/KnVQ4xWG2NtN0J0hjPw7eE06A==}
+
   fraction.js@4.3.7:
     resolution: {integrity: sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==}
 
@@ -3391,6 +3742,10 @@ packages:
     resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==}
     engines: {node: '>= 0.4'}
 
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
   get-iterator@1.0.2:
     resolution: {integrity: sha512-v+dm9bNVfOYsY1OrhaCrmyOcYoSeVvbt+hHZ0Au+T+p1y+0Uyj9aMaGIeUTT6xdpRbWzDeYKvfOslPhggQMcsg==}
 
@@ -3402,6 +3757,14 @@ packages:
     resolution: {integrity: sha512-/b3jarXkH8KJoOMQc3uVGHASwGLPq3gSFJ7tgJm2diza+bydJPTGOibin2steecKeOylE8oY2JERlVWkAJO6yw==}
     engines: {node: '>=6'}
 
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  get-random-values@2.1.0:
+    resolution: {integrity: sha512-q2yOLpLyA8f9unfv2LV8KVRUFeOIrQVS5cnqpbv6N+ea9j1rmW5dFKj/2Q7CK3juEfDYQgPxGt941VJcmw0jKg==}
+    engines: {node: 14 || 16 || >=18}
+
   get-stream@5.2.0:
     resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==}
     engines: {node: '>=8'}
@@ -3433,6 +3796,9 @@ packages:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
     deprecated: Glob versions prior to v9 are no longer supported
 
+  global@4.4.0:
+    resolution: {integrity: sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==}
+
   globals@11.12.0:
     resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
     engines: {node: '>=4'}
@@ -3452,6 +3818,10 @@ packages:
   gopd@1.0.1:
     resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==}
 
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
   graceful-fs@4.2.11:
     resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
 
@@ -3480,6 +3850,10 @@ packages:
     resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
     engines: {node: '>= 0.4'}
 
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
   has-tostringtag@1.0.2:
     resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
     engines: {node: '>= 0.4'}
@@ -3487,6 +3861,16 @@ packages:
   has-unicode@2.0.1:
     resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==}
 
+  hash-base@3.1.2:
+    resolution: {integrity: sha512-Bb33KbowVTIj5s7Ked1OsqHUeCpz//tPwR+E2zJgJKo9Z5XolZ9b6bdUgjmYlwnWhoOQKoTd1TYToZGn5mAYOg==}
+    engines: {node: '>= 0.8'}
+
+  hash.js@1.1.7:
+    resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==}
+
+  hashlru@2.3.0:
+    resolution: {integrity: sha512-0cMsjjIC8I+D3M44pOQdsy0OHXGLVz6Z0beRuufhKa0KfaD2wGwAev6jILzXsd3/vpnNQJmWyZtIILqM1N+n5A==}
+
   hasown@2.0.1:
     resolution: {integrity: sha512-1/th4MHjnwncwXsIW6QMzlvYL9kG5e/CpVvLRZe4XPa8TOUNbCELqmvhDmnkNsAjwaG4+I8gJJL0JBvTTLO9qA==}
     engines: {node: '>= 0.4'}
@@ -3495,6 +3879,10 @@ packages:
     resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
     engines: {node: '>= 0.4'}
 
+  hasown@2.0.4:
+    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
+    engines: {node: '>= 0.4'}
+
   hast-util-to-estree@3.1.0:
     resolution: {integrity: sha512-lfX5g6hqVh9kjS/B9E2gSkvHH4SZNiQFiqWS0x9fENzEl+8W12RqdRxX6d/Cwxi30tPQs3bIO+aolQJNp1bIyw==}
 
@@ -3552,6 +3940,10 @@ packages:
     resolution: {integrity: sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==}
     engines: {node: '>=8.12.0'}
 
+  i@0.3.7:
+    resolution: {integrity: sha512-FYz4wlXgkQwIPqhzC5TdNMLSE5+GS1IIDJZY/1ZiEPCT2S3COUVZeT5OW4BmW4r5LHLQuOosSwsvnroG9GR59Q==}
+    engines: {node: '>=0.4'}
+
   iconv-lite@0.4.24:
     resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}
     engines: {node: '>=0.10.0'}
@@ -3598,6 +3990,14 @@ packages:
   invariant@2.2.4:
     resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==}
 
+  ip-address@10.4.0:
+    resolution: {integrity: sha512-oSK96Grm3aP6OrS263xVxbNDGVL7rzBtYdpGqlDG8iQdoenDoTs/nkki+DflYbAEE8Xl6o5YxhxlrKvI3nqKXQ==}
+    engines: {node: '>= 12'}
+
+  ip-address@9.0.5:
+    resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
+    engines: {node: '>= 12'}
+
   ipfs-utils@9.0.14:
     resolution: {integrity: sha512-zIaiEGX18QATxgaS0/EOQNoo33W0islREABAcxXE8n7y2MGAlB+hdsxXn4J0hGZge8IqVQhW8sWIb+oJz2yEvg==}
     engines: {node: '>=16.0.0', npm: '>=7.0.0'}
@@ -3608,6 +4008,10 @@ packages:
   is-alphanumerical@2.0.1:
     resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==}
 
+  is-arguments@1.2.0:
+    resolution: {integrity: sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==}
+    engines: {node: '>= 0.4'}
+
   is-array-buffer@3.0.4:
     resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==}
     engines: {node: '>= 0.4'}
@@ -3736,6 +4140,10 @@ packages:
     resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==}
     engines: {node: '>= 0.4'}
 
+  is-typed-array@1.1.15:
+    resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
+    engines: {node: '>= 0.4'}
+
   is-weakmap@2.0.1:
     resolution: {integrity: sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==}
 
@@ -3748,6 +4156,9 @@ packages:
   isarray@0.0.1:
     resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==}
 
+  isarray@1.0.0:
+    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
+
   isarray@2.0.5:
     resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
 
@@ -3758,6 +4169,11 @@ packages:
     resolution: {integrity: sha512-9JPDgCN4B7QPkLtYAAOrEuAWvP9rWvR5offAr0/SeF046wIkglqH3VXgYYP6NcsKslH80UIVgmPqNe3j7tG2ng==}
     engines: {node: '>=12'}
 
+  isomorphic-ws@4.0.1:
+    resolution: {integrity: sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==}
+    peerDependencies:
+      ws: '*'
+
   it-all@1.0.6:
     resolution: {integrity: sha512-3cmCc6Heqe3uWi3CVM/k51fa/XbMFpQVzFoDsV0IZNHSQDyAXl3c4MjHkFX5kF3922OGj7Myv1nSEUgRtcuM1A==}
 
@@ -3789,11 +4205,17 @@ packages:
     resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
     hasBin: true
 
+  jsbn@1.1.0:
+    resolution: {integrity: sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==}
+
   jsesc@2.5.2:
     resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==}
     engines: {node: '>=4'}
     hasBin: true
 
+  json-bigint@1.0.0:
+    resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==}
+
   json-buffer@3.0.1:
     resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
 
@@ -3851,6 +4273,18 @@ packages:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
+  libsodium-sumo@0.7.16:
+    resolution: {integrity: sha512-x6atrz2AdXCJg6G709x9W9TTJRI6/0NcL5dD0l5GGVqNE48UJmDsjO4RUWYTeyXXUpg+NXZ2SHECaZnFRYzwGA==}
+
+  libsodium-sumo@0.8.4:
+    resolution: {integrity: sha512-TMtHShQfVVsaxDygyapvUC3o7YsPgXa/hRWeIgzyFz6w5k/1hirGptCxp1U7XwW3rCskaTTYKgV10v86UiGgNw==}
+
+  libsodium-wrappers-sumo@0.7.10:
+    resolution: {integrity: sha512-1noz8Mcl/LUzO/iSO/FJzoJyIaPwxl+/+E4CoTIXtsPiEEXQx2sxalmrVWxteLpynqgX0ASo28ChB9NEVRh0Pg==}
+
+  libsodium-wrappers-sumo@0.8.4:
+    resolution: {integrity: sha512-ql7hcgulKZ3ekfa2DGAogcCKsWU0diA/0nArz1CFzh93WQdb46/Kj18ka/Hifq6uA3Ush34Pc6vU/6HXeRwUkg==}
+
   lightningcss-darwin-arm64@1.24.1:
     resolution: {integrity: sha512-1jQ12jBy+AE/73uGQWGSafK5GoWgmSiIQOGhSEXiFJSZxzV+OXIx+a9h2EYHxdJfX864M+2TAxWPWb0Vv+8y4w==}
     engines: {node: '>= 12.0.0'}
@@ -3949,6 +4383,9 @@ packages:
   lodash.merge@4.6.2:
     resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
 
+  lodash@4.18.1:
+    resolution: {integrity: sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==}
+
   long@5.2.3:
     resolution: {integrity: sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==}
 
@@ -3973,10 +4410,6 @@ packages:
     resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
     engines: {node: '>=10'}
 
-  lucid-cardano@0.10.10:
-    resolution: {integrity: sha512-Yp1o8/kbVUgkRpQqllGQCT9I9w70a+uQKSoJdZEHVrEo5MFbT3Vds314Q8ClqgExzN7pj9NHGbiwiow2ik7mUA==}
-    engines: {node: '>=14'}
-
   magic-bytes.js@1.10.0:
     resolution: {integrity: sha512-/k20Lg2q8LE5xiaaSkMXk4sfvI+9EGEykFS4b0CHHGWqDYU0bGUFSwchNOMA56D7TCs9GwVTkqe9als1/ns8UQ==}
 
@@ -3984,6 +4417,9 @@ packages:
     resolution: {integrity: sha512-8vBuFF/I/+OSLRmdf2wwFCJCz+nSn0m6DPvGH1fS/KiQoSaR+sETbov0eIk9KhEKy8CYqIkIAnbohxT/4H0kuA==}
     engines: {node: '>=12'}
 
+  main-event@1.0.4:
+    resolution: {integrity: sha512-sKazUjIy2Jalv5lkQ446iOcrx8Q7TkaCuk6xfnzg5uUqMusMLDMPmRDmSNE2kjSVpSTJo4j1bQZusS+Ib7Bvrg==}
+
   make-dir@3.1.0:
     resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
     engines: {node: '>=8'}
@@ -3995,6 +4431,13 @@ packages:
     resolution: {integrity: sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==}
     engines: {node: '>=16'}
 
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  md5.js@1.3.5:
+    resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==}
+
   mdast-util-from-markdown@2.0.0:
     resolution: {integrity: sha512-n7MTOr/z+8NAX/wmhhDji8O3bRvPTV/U0oTCaZJkjhPSKTPhS3xufVhKGF8s1pJ7Ox4QgoIU7KHseh09S+9rTA==}
 
@@ -4145,6 +4588,12 @@ packages:
     resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
     engines: {node: '>=12'}
 
+  min-document@2.19.2:
+    resolution: {integrity: sha512-8S5I8db/uZN8r9HSLFVWPdJCvYOejMcEC82VIzNUc6Zkklf/d1gg2psfE79/vyhWOj4+J8MtwmoOz3TmvaGu5A==}
+
+  minimalistic-assert@1.0.1:
+    resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==}
+
   minimatch@3.1.2:
     resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
 
@@ -4217,6 +4666,9 @@ packages:
   multiformats@13.1.0:
     resolution: {integrity: sha512-HzdtdBwxsIkzpeXzhQ5mAhhuxcHbjEHH+JQoxt7hG/2HGFjjwyolLo7hbaexcnhoEuV4e0TNJ8kkpMjiEYY4VQ==}
 
+  multiformats@14.0.5:
+    resolution: {integrity: sha512-vbIm83F2yZ1pWJGS0yl0ysracIvv56LtbrIyiIQHoLdYDJOMoLfVFsXhh9DUH4SFdkdkFhucyWniihsNzVEjkQ==}
+
   murmurhash3js-revisited@3.0.0:
     resolution: {integrity: sha512-/sF3ee6zvScXMb1XFJ8gDsSnY+X8PbOyjIuBhtgis10W2Jx4ZjIhikUCIF9c4gpJxVnQIsPAFrSwTCuAjicP6g==}
     engines: {node: '>=8.0.0'}
@@ -4224,6 +4676,12 @@ packages:
   mz@2.7.0:
     resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
 
+  nan@2.28.0:
+    resolution: {integrity: sha512-fTsDz99OTq2sVePhGdp4qQhggZFtKr64ZNVyVajRKtMOkJxYekplBh577PiJB12v/D3s2E5cGtOI45LWp6rnLQ==}
+
+  nanoassert@2.0.0:
+    resolution: {integrity: sha512-7vO7n28+aYO4J+8w96AzhmU8G+Y/xpPDJz/se19ICsqj/momRbb9mh9ZUtkoJ5X3nTnPdhEJyc0qnM6yAsHBaA==}
+
   nanoid@3.3.7:
     resolution: {integrity: sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
@@ -4319,6 +4777,10 @@ packages:
   node-releases@2.0.14:
     resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==}
 
+  nofilter@3.1.0:
+    resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==}
+    engines: {node: '>=12.19'}
+
   nopt@5.0.0:
     resolution: {integrity: sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==}
     engines: {node: '>=6'}
@@ -4434,10 +4896,18 @@ packages:
     resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
     engines: {node: '>=10'}
 
+  p-queue@9.3.3:
+    resolution: {integrity: sha512-NXAOdnEe5FsZJfT4oK84lE1Y5cFFdWlRuOo5tww8DyNMxyRXwn39fIkUtNLKppcPC+UYU/bXujNCUGDv01y7CA==}
+    engines: {node: '>=20'}
+
   p-retry@5.1.2:
     resolution: {integrity: sha512-couX95waDu98NfNZV+i/iLt+fdVxmI7CbrrdC2uDWfPdUAApyxT4wmDlyOtR5KtTDmkDO0zDScDjDou9YHhd9g==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  p-timeout@7.0.1:
+    resolution: {integrity: sha512-AxTM2wDGORHGEkPCt8yqxOTMgpfbEHqF51f/5fJCmwFC3C/zNcGT63SymH2ttOAaiIws2zVg4+izQCjrakcwHg==}
+    engines: {node: '>=20'}
+
   parcel@2.12.0:
     resolution: {integrity: sha512-W+gxAq7aQ9dJIg/XLKGcRT0cvnStFAQHPaI0pvD0U2l6IVLueUAm3nwN7lkY62zZNmlvNx6jNtE4wlbS+CyqSg==}
     engines: {node: '>= 12.0.0'}
@@ -4502,6 +4972,10 @@ packages:
   pathval@1.1.1:
     resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
 
+  pbkdf2@3.1.6:
+    resolution: {integrity: sha512-BT6eelPB1EyGHo8pC0o9Bl6k6SYVhKO1jEbd3lcTrtr7XHdjP8BW1YpfCV3G9Kwkxgattk+S5q2/RvuttCsS1g==}
+    engines: {node: '>= 0.10'}
+
   pend@1.2.0:
     resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
 
@@ -4661,6 +5135,16 @@ packages:
     resolution: {integrity: sha512-973driJZvxiGOQ5ONsFhOF/DtzPMOMtgC11kCpUrPGMTgqp2q/1gwzCquocrN33is0VZ5GFHXZYMM9l6h67v2Q==}
     engines: {node: '>=10'}
 
+  process-nextick-args@2.0.1:
+    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
+
+  process@0.11.10:
+    resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
+    engines: {node: '>= 0.6.0'}
+
+  progress-events@1.1.0:
+    resolution: {integrity: sha512-82DVc5tI36neVB3IjdXR11ztwGuoBc98em9ijzubeZKxI47OlV2Znq6mlPqE5xPDzO2Uw98GHiQSjj2favBCRQ==}
+
   promisepipe@3.0.0:
     resolution: {integrity: sha512-V6TbZDJ/ZswevgkDNpGt/YqNCiZP9ASfgU+p83uJE6NrGtvSGoOcHLiDCqkMs2+yg7F5qHdLV8d0aS8O26G/KA==}
 
@@ -4674,6 +5158,10 @@ packages:
     resolution: {integrity: sha512-dgJaEDDL6x8ASUZ1YqWciTRrdOuYNzoOf27oHNfdyvKqHr5i0FV7FSLU+aIeFjyFgVxrpTOtQUi0BLLBymZaBw==}
     engines: {node: '>=12.0.0'}
 
+  proxy-from-env@2.1.0:
+    resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==}
+    engines: {node: '>=10'}
+
   pump@3.0.0:
     resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==}
 
@@ -4785,6 +5273,12 @@ packages:
   read-cache@1.0.0:
     resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==}
 
+  readable-stream@1.1.14:
+    resolution: {integrity: sha512-+MeVjFf4L44XUkhM1eYbD8fyEsxcV81pqMSR5gblfcLCHfZvbrqy4/qYHE+/R5HoBUT11WV5O08Cr1n3YXkWVQ==}
+
+  readable-stream@2.3.8:
+    resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
+
   readable-stream@3.6.2:
     resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
     engines: {node: '>= 6'}
@@ -4856,6 +5350,10 @@ packages:
     deprecated: Rimraf versions prior to v4 are no longer supported
     hasBin: true
 
+  ripemd160@2.0.3:
+    resolution: {integrity: sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==}
+    engines: {node: '>= 0.8'}
+
   rollup@4.11.0:
     resolution: {integrity: sha512-2xIbaXDXjf3u2tajvA5xROpib7eegJ9Y/uPlSFhXLNpK9ampCczXAhLEb5yLzJyG3LAdI1NWtNjDXiLyniNdjQ==}
     engines: {node: '>=18.0.0', npm: '>=8.0.0'}
@@ -4864,6 +5362,9 @@ packages:
   run-parallel@1.2.0:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
+  rxjs@7.8.2:
+    resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==}
+
   safe-array-concat@1.1.0:
     resolution: {integrity: sha512-ZdQ0Jeb9Ofti4hbt5lX3T2JcAamT9hfzYU1MNB+z/jaEbB6wfFfPIR/zEORmZqobkCCJhSjodobH6WHNmJ97dg==}
     engines: {node: '>=0.4'}
@@ -4872,6 +5373,9 @@ packages:
     resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==}
     engines: {node: '>=0.4'}
 
+  safe-buffer@5.1.2:
+    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
+
   safe-buffer@5.2.1:
     resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
 
@@ -4882,6 +5386,12 @@ packages:
   safer-buffer@2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
 
+  scalus@0.14.2:
+    resolution: {integrity: sha512-dobDMIUDUVhtxoX3ceGlaykKQGkph4HOE9hjkLsmwVgYf24fIik6YrZzVFrZSNCTvI2WN7hjEknehIrEJo1CMQ==}
+
+  scalus@0.17.0:
+    resolution: {integrity: sha512-74mD4wL1vw4GVh2ECemQhoB3q5Smwj5S8W7OG1j7OWuLkwJ0Mvz4LFhZPA9rZjpNvanZoKiDqc3S/qGD65uRYg==}
+
   scheduler@0.23.2:
     resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
 
@@ -4903,6 +5413,10 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  serialize-error@8.1.0:
+    resolution: {integrity: sha512-3NnuWfM6vBYoy5gZFvHiYsVbafvI9vZv/+jlIigFn4oP4zjNPK3LhcY0xSCgeb1a5L8jO71Mit9LlNoi2UfDDQ==}
+    engines: {node: '>=10'}
+
   serialize-javascript@6.0.2:
     resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==}
 
@@ -4913,6 +5427,10 @@ packages:
     resolution: {integrity: sha512-j4t6ccc+VsKwYHso+kElc5neZpjtq9EnRICFZtWyBsLojhmeF/ZBd/elqm22WJh/BziDe/SBiOeAt0m2mfLD0g==}
     engines: {node: '>= 0.4'}
 
+  set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
+    engines: {node: '>= 0.4'}
+
   set-function-name@2.0.2:
     resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==}
     engines: {node: '>= 0.4'}
@@ -4920,6 +5438,11 @@ packages:
   setprototypeof@1.1.1:
     resolution: {integrity: sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw==}
 
+  sha.js@2.4.12:
+    resolution: {integrity: sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==}
+    engines: {node: '>= 0.10'}
+    hasBin: true
+
   sharp@0.33.3:
     resolution: {integrity: sha512-vHUeXJU1UvlO/BNwTpT0x/r53WkLUVxrmb5JTgW92fdFCFk0ispLMAeu/jPO2vjkXM1fYUi3K7/qcLF47pwM1A==}
     engines: {libvips: '>=8.15.2', node: ^18.17.0 || ^20.3.0 || >=21.0.0}
@@ -4985,6 +5508,9 @@ packages:
   space-separated-tokens@2.0.2:
     resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
 
+  sprintf-js@1.1.3:
+    resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==}
+
   srcset@4.0.0:
     resolution: {integrity: sha512-wvLeHgcVHKO8Sc/H/5lkGreJQVeYMm9rlmt8PuR1xE31rIuXhuzznUUqAt8MqLhB3MqJdFzlNAfpcWnxiFUcPw==}
     engines: {node: '>=12'}
@@ -5051,6 +5577,12 @@ packages:
     resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==}
     engines: {node: '>= 0.4'}
 
+  string_decoder@0.10.31:
+    resolution: {integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==}
+
+  string_decoder@1.1.1:
+    resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
+
   string_decoder@1.3.0:
     resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
 
@@ -5209,6 +5741,10 @@ packages:
     resolution: {integrity: sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==}
     engines: {node: '>=14.0.0'}
 
+  to-buffer@1.2.2:
+    resolution: {integrity: sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==}
+    engines: {node: '>= 0.4'}
+
   to-fast-properties@2.0.0:
     resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}
     engines: {node: '>=4'}
@@ -5240,9 +5776,16 @@ packages:
     peerDependencies:
       typescript: '>=4.2.0'
 
+  ts-custom-error@3.3.1:
+    resolution: {integrity: sha512-5OX1tzOjxWEgsr/YEUWSuPrQ00deKLh6D7OTWcvNHm12/7QPyRh8SYpyWvA4IZv8H/+GQWQEh/kwo95Q9OVW1A==}
+    engines: {node: '>=14.0.0'}
+
   ts-interface-checker@0.1.13:
     resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
 
+  ts-log@2.2.7:
+    resolution: {integrity: sha512-320x5Ggei84AxzlXp91QkIGSw5wgaLT6GeAH0KsqDmRZdVWW2OiSeVvElVoatk3f7nicwXlElXsoFkARiGE2yg==}
+
   ts-morph@12.0.0:
     resolution: {integrity: sha512-VHC8XgU2fFW7yO1f/b3mxKDje1vmyzFXHWzOYmKEkCEwcLjDtbdLgBQviqj4ZwP4MJkQtRo6Ha2I29lq/B+VxA==}
 
@@ -5293,6 +5836,10 @@ packages:
     resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==}
     engines: {node: '>= 0.4'}
 
+  typed-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
+    engines: {node: '>= 0.4'}
+
   typed-array-byte-length@1.0.1:
     resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==}
     engines: {node: '>= 0.4'}
@@ -5334,15 +5881,27 @@ packages:
     resolution: {integrity: sha512-u3xV3X7uzvi5b1MncmZo3i2Aw222Zk1keqLA1YkHldREkAhAqi65wuPfe7lHx8H/Wzy+8CE7S7uS3jekIM5s8g==}
     engines: {node: '>=8'}
 
+  uint8-varint@2.0.5:
+    resolution: {integrity: sha512-jeFLbL/x30wBRnWjKE1qVBXeumG46r7XmYkpis955lTQ+blccGKFrOsSMHlxePwYB1pI7L8YPHz1t4jLxEs3nA==}
+
+  uint8-varint@3.0.0:
+    resolution: {integrity: sha512-S4DdpXBaLwKcFo7f0bWzWfHjbZ/i3QhM842qn+ZvHjxqFCfUcEB9SQNcmI69S+zMlcmIcKxsk9Iyw77S2Kxv6Q==}
+
   uint8arraylist@2.4.8:
     resolution: {integrity: sha512-vc1PlGOzglLF0eae1M8mLRTBivsvrGsdmJ5RbK3e+QRvRLOZfZhQROTwH/OfyF3+ZVUg9/8hE8bmKP2CvP9quQ==}
 
+  uint8arraylist@3.0.2:
+    resolution: {integrity: sha512-LDVoq9BQaGJzGDUovEnoX6rpKCvnY/Jbtws4ikwnBzjRbq5qBAFpBZevUEbSmMM87aO0Sp+wOZy2ZXf5yODmXQ==}
+
   uint8arrays@4.0.10:
     resolution: {integrity: sha512-AnJNUGGDJAgFw/eWu/Xb9zrVKEGlwJJCaeInlf3BkecE/zcTobk5YXYIPNQJO1q5Hh1QZrQQHf0JvcHqz2hqoA==}
 
   uint8arrays@5.0.3:
     resolution: {integrity: sha512-6LBuKji28kHjgPJMkQ6GDaBb1lRwIhyOYq6pDGwYMoDPfImE9SkuYENVmR0yu9yGgs2clHUSY9fKDukR+AXfqQ==}
 
+  uint8arrays@6.1.1:
+    resolution: {integrity: sha512-iz7JN0XCSZYA111lhFG2Ui9EhFvTNekqSRHw3lvMHq+dzwWy1OQftxFQREEh4rffU0oSoXdQHsk2TiHKVm4fsA==}
+
   unbox-primitive@1.0.2:
     resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==}
 
@@ -5353,6 +5912,10 @@ packages:
     resolution: {integrity: sha512-cSb4bPFd5qgR7qr2jYAi0hlX9n5YKK2ONKkLFkxl+v/9BvC0sOpZjBHDBSXc5lWAf5ty9oZdRXytBIHzgUcerw==}
     engines: {node: '>=14.0'}
 
+  undici@5.29.0:
+    resolution: {integrity: sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==}
+    engines: {node: '>=14.0'}
+
   unified@11.0.4:
     resolution: {integrity: sha512-apMPnyLjAX+ty4OrNap7yumyVAMlKx5IWU2wlzzUdYJO9A8f1p9m/gywF/GM2ZDFcjQPrx59Mc90KwmxsoklxQ==}
 
@@ -5424,9 +5987,15 @@ packages:
     peerDependencies:
       react: ^16.8.0  || ^17 || ^18
 
+  utf8-codec@1.0.0:
+    resolution: {integrity: sha512-S/QSLezp3qvG4ld5PUfXiH7mCFxLKjSVZRFkB3DOjgwHuJPFDkInAXc/anf7BAbHt/D38ozDzL+QMZ6/7gsI6w==}
+
   util-deprecate@1.0.2:
     resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
 
+  util@0.12.5:
+    resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==}
+
   utility-types@3.11.0:
     resolution: {integrity: sha512-6Z7Ma2aVEWisaL6TvBCy7P8rm2LQoPv6dJ7ecIaIixHcwfbJ0x7mWdbcwlIM5IGQxPZSFYeqRCqlOOeKoJYMkw==}
     engines: {node: '>= 4'}
@@ -5533,6 +6102,9 @@ packages:
   weak-lru-cache@1.2.2:
     resolution: {integrity: sha512-DEAoo25RfSYMuTGc9vPJzZcZullwIqRDSI9LOy+fkCJPi6hykCnfKaXTuPBDuXAUcqHXyOgFtHNp/kB2FjYHbw==}
 
+  web-encoding@1.1.5:
+    resolution: {integrity: sha512-HYLeVCdJ0+lBYV2FvNZmv3HJ2Nt0QYXqZojk3d9FJOLkwnuhzM9tmamh8d7HPM8QqjKH8DeHkFTx+CFlWpZZDA==}
+
   web-streams-polyfill@3.3.2:
     resolution: {integrity: sha512-3pRGuxRF5gpuZc0W+EpwQRmCD7gRqcDOMt688KmdlDAgAyaB1XlN0zq2njfDNm44XVdIouE7pZ6GzbdyH47uIQ==}
     engines: {node: '>= 8'}
@@ -5543,6 +6115,9 @@ packages:
   webcrypto-core@1.7.9:
     resolution: {integrity: sha512-FE+a4PPkOmBbgNDIyRmcHhgXn+2ClRl3JzJdDu/P4+B8y81LqKe6RAsI9b3lAOHe1T1BMkSjsRHTYRikImZnVA==}
 
+  webextension-polyfill@0.8.0:
+    resolution: {integrity: sha512-a19+DzlT6Kp9/UI+mF9XQopeZ+n2ussjhxHJ4/pmIGge9ijCDz7Gn93mNnjpZAk95T4Tae8iHZ6sSf869txqiQ==}
+
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
@@ -5584,6 +6159,10 @@ packages:
     resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==}
     engines: {node: '>= 0.4'}
 
+  which-typed-array@1.1.22:
+    resolution: {integrity: sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==}
+    engines: {node: '>= 0.4'}
+
   which@2.0.2:
     resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
     engines: {node: '>= 8'}
@@ -5608,6 +6187,18 @@ packages:
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
+  ws@7.5.13:
+    resolution: {integrity: sha512-rsKI6xDBFVf4r/x8XyChGK04QR/XHroxs/jUcoWvtEZM8TPU/X/uIY9B1CsSzYws9ZJb/6bbBu7dPhFW00CAoA==}
+    engines: {node: '>=8.3.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
   ws@8.16.0:
     resolution: {integrity: sha512-HS0c//TP7Ina87TfiPUz1rQzMhHrl/SG2guqRcTOIUYD2q8uhUdNHZYJUaQ8aTGPzCh+c6oawMKW35nFl1dxyQ==}
     engines: {node: '>=10.0.0'}
@@ -5808,10 +6399,207 @@ snapshots:
       '@babel/helper-validator-identifier': 7.22.20
       to-fast-properties: 2.0.0
 
+  '@biglup/is-cid@1.0.3':
+    dependencies:
+      '@multiformats/mafmt': 12.1.6
+      '@multiformats/multiaddr': 12.5.1
+      iso-url: 1.2.1
+      multiformats: 13.1.0
+      uint8arrays: 5.0.3
+
+  '@bufbuild/protobuf@1.10.1': {}
+
+  '@cardano-ogmios/client@6.9.0(encoding@0.1.13)':
+    dependencies:
+      '@cardano-ogmios/schema': 6.9.0
+      '@cardanosolutions/json-bigint': 1.1.0
+      '@types/json-bigint': 1.0.4
+      bech32: 2.0.0
+      cross-fetch: 3.2.0(encoding@0.1.13)
+      fastq: 1.17.1
+      isomorphic-ws: 4.0.1(ws@7.5.13)
+      nanoid: 3.3.7
+      ts-custom-error: 3.3.1
+      ws: 7.5.13
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - utf-8-validate
+
+  '@cardano-ogmios/schema@6.9.0': {}
+
+  '@cardano-sdk/core@0.46.12(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@biglup/is-cid': 1.0.3
+      '@cardano-ogmios/client': 6.9.0(encoding@0.1.13)
+      '@cardano-ogmios/schema': 6.9.0
+      '@cardano-sdk/crypto': 0.4.7
+      '@cardano-sdk/util': 0.17.1
+      '@foxglove/crc': 0.0.3
+      '@scure/base': 1.1.5
+      fraction.js: 4.0.1
+      ip-address: 9.0.5
+      lodash: 4.18.1
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+      web-encoding: 1.1.5
+    optionalDependencies:
+      rxjs: 7.8.2
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - utf-8-validate
+
+  '@cardano-sdk/core@0.47.0':
+    dependencies:
+      '@biglup/is-cid': 1.0.3
+      '@cardano-sdk/crypto': 0.4.7
+      '@cardano-sdk/util': 0.17.2
+      '@foxglove/crc': 0.0.3
+      '@scure/base': 1.1.5
+      fraction.js: 4.0.1
+      ip-address: 10.4.0
+      lodash: 4.18.1
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+      web-encoding: 1.1.5
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - react-native-b4a
+
+  '@cardano-sdk/crypto@0.4.5':
+    dependencies:
+      '@cardano-sdk/util': 0.17.1
+      blake2b: 2.1.4
+      i: 0.3.7
+      libsodium-wrappers-sumo: 0.7.10
+      lodash: 4.18.1
+      pbkdf2: 3.1.6
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  '@cardano-sdk/crypto@0.4.7':
+    dependencies:
+      '@cardano-sdk/util': 0.17.2
+      blake2b: 2.1.4
+      i: 0.3.7
+      libsodium-wrappers-sumo: 0.8.4
+      lodash: 4.18.1
+      pbkdf2: 3.1.6
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  '@cardano-sdk/dapp-connector@0.13.30':
+    dependencies:
+      '@cardano-sdk/core': 0.47.0
+      '@cardano-sdk/crypto': 0.4.7
+      '@cardano-sdk/util': 0.17.2
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+      webextension-polyfill: 0.8.0
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - react-native-b4a
+
+  '@cardano-sdk/input-selection@0.14.28(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@cardano-sdk/core': 0.46.12(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/key-management': 0.29.18
+      '@cardano-sdk/util': 0.17.1
+      bignumber.js: 9.3.1
+      lodash: 4.18.1
+      ts-custom-error: 3.3.1
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - utf-8-validate
+
+  '@cardano-sdk/key-management@0.29.18':
+    dependencies:
+      '@cardano-sdk/core': 0.47.0
+      '@cardano-sdk/crypto': 0.4.7
+      '@cardano-sdk/dapp-connector': 0.13.30
+      '@cardano-sdk/util': 0.17.2
+      '@emurgo/cardano-message-signing-nodejs': 1.1.0
+      bip39: 3.1.0
+      chacha: 2.1.0
+      get-random-values: 2.1.0
+      lodash: 4.18.1
+      pbkdf2: 3.1.6
+      rxjs: 7.8.2
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - react-native-b4a
+
+  '@cardano-sdk/util@0.17.1':
+    dependencies:
+      bech32: 2.0.0
+      lodash: 4.18.1
+      serialize-error: 8.1.0
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+
+  '@cardano-sdk/util@0.17.2':
+    dependencies:
+      bech32: 2.0.0
+      lodash: 4.18.1
+      serialize-error: 8.1.0
+      ts-custom-error: 3.3.1
+      ts-log: 2.2.7
+
+  '@cardanosolutions/json-bigint@1.1.0': {}
+
+  '@chainsafe/is-ip@2.1.0': {}
+
+  '@chainsafe/netmask@2.0.0':
+    dependencies:
+      '@chainsafe/is-ip': 2.1.0
+
+  '@connectrpc/connect-node@1.4.0(@bufbuild/protobuf@1.10.1)(@connectrpc/connect@1.4.0(@bufbuild/protobuf@1.10.1))':
+    dependencies:
+      '@bufbuild/protobuf': 1.10.1
+      '@connectrpc/connect': 1.4.0(@bufbuild/protobuf@1.10.1)
+      undici: 5.29.0
+
+  '@connectrpc/connect-web@1.4.0(@bufbuild/protobuf@1.10.1)(@connectrpc/connect@1.4.0(@bufbuild/protobuf@1.10.1))':
+    dependencies:
+      '@bufbuild/protobuf': 1.10.1
+      '@connectrpc/connect': 1.4.0(@bufbuild/protobuf@1.10.1)
+
+  '@connectrpc/connect@1.4.0(@bufbuild/protobuf@1.10.1)':
+    dependencies:
+      '@bufbuild/protobuf': 1.10.1
+
   '@cspotcode/source-map-support@0.8.1':
     dependencies:
       '@jridgewell/trace-mapping': 0.3.9
 
+  '@dnsquery/dns-packet@6.1.1':
+    dependencies:
+      '@leichtgewicht/ip-codec': 2.0.5
+      utf8-codec: 1.0.0
+
   '@edge-runtime/format@2.2.1': {}
 
   '@edge-runtime/node-utils@2.3.0': {}
@@ -5829,6 +6617,8 @@ snapshots:
       tslib: 2.6.2
     optional: true
 
+  '@emurgo/cardano-message-signing-nodejs@1.1.0': {}
+
   '@esbuild/aix-ppc64@0.19.12':
     optional: true
 
@@ -5940,6 +6730,57 @@ snapshots:
 
   '@floating-ui/utils@0.2.1': {}
 
+  '@foxglove/crc@0.0.3': {}
+
+  '@harmoniclabs/bigint-utils@1.0.0':
+    dependencies:
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
+  '@harmoniclabs/biguint@1.0.0': {}
+
+  '@harmoniclabs/bitstream@1.0.0':
+    dependencies:
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
+  '@harmoniclabs/bytestring@1.0.0':
+    dependencies:
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
+  '@harmoniclabs/cbor@1.6.0':
+    dependencies:
+      '@harmoniclabs/bytestring': 1.0.0
+      '@harmoniclabs/obj-utils': 1.0.0
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
+  '@harmoniclabs/crypto@0.2.5':
+    dependencies:
+      '@harmoniclabs/bitstream': 1.0.0
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
+  '@harmoniclabs/obj-utils@1.0.0': {}
+
+  '@harmoniclabs/pair@1.0.0': {}
+
+  '@harmoniclabs/plutus-data@1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)':
+    dependencies:
+      '@harmoniclabs/biguint': 1.0.0
+      '@harmoniclabs/bytestring': 1.0.0
+      '@harmoniclabs/cbor': 1.6.0
+      '@harmoniclabs/crypto': 0.2.5
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
+  '@harmoniclabs/uint8array-utils@1.0.4': {}
+
+  '@harmoniclabs/uplc@1.4.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)(@harmoniclabs/crypto@0.2.5)(@harmoniclabs/pair@1.0.0)(@harmoniclabs/plutus-data@1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0))':
+    dependencies:
+      '@harmoniclabs/bigint-utils': 1.0.0
+      '@harmoniclabs/bytestring': 1.0.0
+      '@harmoniclabs/cbor': 1.6.0
+      '@harmoniclabs/crypto': 0.2.5
+      '@harmoniclabs/pair': 1.0.0
+      '@harmoniclabs/plutus-data': 1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)
+      '@harmoniclabs/uint8array-utils': 1.0.4
+
   '@hookform/error-message@2.0.1(react-dom@18.3.1(react@18.3.1))(react-hook-form@7.51.5(react@18.3.1))(react@18.3.1)':
     dependencies:
       react: 18.3.1
@@ -6126,12 +6967,23 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.4.15
 
+  '@leichtgewicht/ip-codec@2.0.5': {}
+
   '@lezer/common@1.2.1': {}
 
   '@lezer/lr@1.4.0':
     dependencies:
       '@lezer/common': 1.2.1
 
+  '@libp2p/interface@3.2.5':
+    dependencies:
+      '@multiformats/dns': 1.0.15
+      '@multiformats/multiaddr': 13.0.3
+      main-event: 1.0.4
+      multiformats: 14.0.5
+      progress-events: 1.1.0
+      uint8arraylist: 3.0.2
+
   '@lmdb/lmdb-darwin-arm64@2.8.5':
     optional: true
 
@@ -6167,11 +7019,11 @@ snapshots:
       - encoding
       - supports-color
 
-  '@mdx-js/loader@3.0.1(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2)))':
+  '@mdx-js/loader@3.0.1(webpack@5.90.3(@swc/core@1.4.17))':
     dependencies:
       '@mdx-js/mdx': 3.0.1
       source-map: 0.7.4
-      webpack: 5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2))
+      webpack: 5.90.3(@swc/core@1.4.17)
     transitivePeerDependencies:
       - supports-color
 
@@ -6209,6 +7061,184 @@ snapshots:
       '@types/react': 18.3.1
       react: 18.3.1
 
+  '@meshsdk/common@1.9.0-beta.100':
+    dependencies:
+      bech32: 2.0.0
+      bip39: 3.1.0
+      blake2b: 2.1.4
+      blakejs: 1.2.1
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  '@meshsdk/common@1.9.1':
+    dependencies:
+      bech32: 2.0.0
+      bip39: 3.1.0
+      blake2b: 2.1.4
+      blakejs: 1.2.1
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  '@meshsdk/core-cst@1.9.0-beta.100(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@cardano-sdk/core': 0.46.12(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/crypto': 0.4.5
+      '@cardano-sdk/input-selection': 0.14.28(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/util': 0.17.1
+      '@harmoniclabs/cbor': 1.6.0
+      '@harmoniclabs/pair': 1.0.0
+      '@harmoniclabs/plutus-data': 1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)
+      '@harmoniclabs/uplc': 1.4.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)(@harmoniclabs/crypto@0.2.5)(@harmoniclabs/pair@1.0.0)(@harmoniclabs/plutus-data@1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0))
+      '@meshsdk/common': 1.9.0-beta.100
+      '@types/base32-encoding': 1.0.2
+      base32-encoding: 1.0.0
+      bech32: 2.0.0
+      blakejs: 1.2.1
+      bn.js: 5.2.5
+      hash.js: 1.1.7
+      scalus: 0.14.2
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - utf-8-validate
+
+  '@meshsdk/core-cst@1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@cardano-sdk/core': 0.46.12(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/crypto': 0.4.5
+      '@cardano-sdk/input-selection': 0.14.28(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/util': 0.17.1
+      '@harmoniclabs/cbor': 1.6.0
+      '@harmoniclabs/pair': 1.0.0
+      '@harmoniclabs/plutus-data': 1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)
+      '@harmoniclabs/uplc': 1.4.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0)(@harmoniclabs/crypto@0.2.5)(@harmoniclabs/pair@1.0.0)(@harmoniclabs/plutus-data@1.2.6(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/cbor@1.6.0))
+      '@meshsdk/common': 1.9.1
+      '@types/base32-encoding': 1.0.2
+      base32-encoding: 1.0.0
+      bech32: 2.0.0
+      blakejs: 1.2.1
+      bn.js: 5.2.5
+      hash.js: 1.1.7
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - utf-8-validate
+
+  '@meshsdk/core@1.9.1(@bufbuild/protobuf@1.10.1)(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@meshsdk/common': 1.9.1
+      '@meshsdk/core-cst': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      '@meshsdk/provider': 1.9.0-beta.101(@bufbuild/protobuf@1.10.1)(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      '@meshsdk/transaction': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      '@meshsdk/wallet': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      scalus: 0.17.0
+    transitivePeerDependencies:
+      - '@bufbuild/protobuf'
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - debug
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - supports-color
+      - utf-8-validate
+
+  '@meshsdk/provider@1.9.0-beta.101(@bufbuild/protobuf@1.10.1)(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@meshsdk/common': 1.9.0-beta.100
+      '@meshsdk/core-cst': 1.9.0-beta.100(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      '@utxorpc/sdk': 0.6.8(@bufbuild/protobuf@1.10.1)
+      '@utxorpc/spec': 0.16.0
+      axios: 1.19.0
+      cbor: 10.0.12
+    transitivePeerDependencies:
+      - '@bufbuild/protobuf'
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - debug
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - supports-color
+      - utf-8-validate
+
+  '@meshsdk/scalus-emulator@1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@meshsdk/common': 1.9.1
+      '@meshsdk/core-cst': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      scalus: 0.17.0
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - utf-8-validate
+
+  '@meshsdk/transaction@1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@cardano-sdk/core': 0.46.12(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/input-selection': 0.14.28(encoding@0.1.13)(rxjs@7.8.2)
+      '@cardano-sdk/util': 0.17.1
+      '@meshsdk/common': 1.9.1
+      '@meshsdk/core-cst': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      json-bigint: 1.0.0
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - utf-8-validate
+
+  '@meshsdk/wallet@1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)':
+    dependencies:
+      '@meshsdk/common': 1.9.1
+      '@meshsdk/core-cst': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      '@meshsdk/transaction': 1.9.1(@harmoniclabs/bytestring@1.0.0)(@harmoniclabs/crypto@0.2.5)(encoding@0.1.13)(rxjs@7.8.2)
+      '@simplewebauthn/browser': 13.3.0
+    transitivePeerDependencies:
+      - '@dcspark/cardano-multiplatform-lib-asmjs'
+      - '@dcspark/cardano-multiplatform-lib-browser'
+      - '@dcspark/cardano-multiplatform-lib-nodejs'
+      - '@harmoniclabs/bytestring'
+      - '@harmoniclabs/crypto'
+      - bufferutil
+      - encoding
+      - react-native-b4a
+      - rxjs
+      - utf-8-validate
+
   '@mischnic/json-sourcemap@0.1.1':
     dependencies:
       '@lezer/common': 1.2.1
@@ -6233,6 +7263,36 @@ snapshots:
   '@msgpackr-extract/msgpackr-extract-win32-x64@3.0.2':
     optional: true
 
+  '@multiformats/dns@1.0.15':
+    dependencies:
+      '@dnsquery/dns-packet': 6.1.1
+      '@libp2p/interface': 3.2.5
+      hashlru: 2.3.0
+      p-queue: 9.3.3
+      progress-events: 1.1.0
+      uint8arrays: 6.1.1
+
+  '@multiformats/mafmt@12.1.6':
+    dependencies:
+      '@multiformats/multiaddr': 12.5.1
+
+  '@multiformats/multiaddr@12.5.1':
+    dependencies:
+      '@chainsafe/is-ip': 2.1.0
+      '@chainsafe/netmask': 2.0.0
+      '@multiformats/dns': 1.0.15
+      abort-error: 1.0.2
+      multiformats: 13.1.0
+      uint8-varint: 2.0.5
+      uint8arrays: 5.0.3
+
+  '@multiformats/multiaddr@13.0.3':
+    dependencies:
+      '@chainsafe/is-ip': 2.1.0
+      multiformats: 14.0.5
+      uint8-varint: 3.0.0
+      uint8arrays: 6.1.1
+
   '@multiformats/murmur3@2.1.8':
     dependencies:
       multiformats: 13.1.0
@@ -6244,11 +7304,11 @@ snapshots:
     dependencies:
       glob: 10.3.10
 
-  '@next/mdx@14.1.3(@mdx-js/loader@3.0.1(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2))))(@mdx-js/react@3.0.1(@types/react@18.3.1)(react@18.3.1))':
+  '@next/mdx@14.1.3(@mdx-js/loader@3.0.1(webpack@5.90.3(@swc/core@1.4.17)))(@mdx-js/react@3.0.1(@types/react@18.3.1)(react@18.3.1))':
     dependencies:
       source-map: 0.7.4
     optionalDependencies:
-      '@mdx-js/loader': 3.0.1(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2)))
+      '@mdx-js/loader': 3.0.1(webpack@5.90.3(@swc/core@1.4.17))
       '@mdx-js/react': 3.0.1(@types/react@18.3.1)(react@18.3.1)
 
   '@next/swc-darwin-arm64@14.1.0':
@@ -7484,6 +8544,8 @@ snapshots:
       '@noble/hashes': 1.3.3
       '@scure/base': 1.1.5
 
+  '@simplewebauthn/browser@13.3.0': {}
+
   '@sinclair/typebox@0.25.24': {}
 
   '@sinclair/typebox@0.27.8': {}
@@ -7549,17 +8611,17 @@ snapshots:
     dependencies:
       '@swc/counter': 0.1.3
 
-  '@tailwindcss/line-clamp@0.4.4(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)))':
+  '@tailwindcss/line-clamp@0.4.4(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)))':
     dependencies:
-      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))
+      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))
 
-  '@tailwindcss/typography@0.5.13(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)))':
+  '@tailwindcss/typography@0.5.13(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)))':
     dependencies:
       lodash.castarray: 4.4.0
       lodash.isplainobject: 4.0.6
       lodash.merge: 4.6.2
       postcss-selector-parser: 6.0.10
-      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))
+      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))
 
   '@tanstack/react-table@8.16.0(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
@@ -7592,6 +8654,10 @@ snapshots:
     dependencies:
       '@types/estree': 1.0.5
 
+  '@types/base32-encoding@1.0.2':
+    dependencies:
+      '@types/node': 20.12.7
+
   '@types/chai-subset@1.3.5':
     dependencies:
       '@types/chai': 4.3.11
@@ -7622,6 +8688,8 @@ snapshots:
     dependencies:
       '@types/unist': 3.0.2
 
+  '@types/json-bigint@1.0.4': {}
+
   '@types/json-schema@7.0.15': {}
 
   '@types/json5@0.0.29': {}
@@ -7746,6 +8814,20 @@ snapshots:
 
   '@ungap/structured-clone@1.2.0': {}
 
+  '@utxorpc/sdk@0.6.8(@bufbuild/protobuf@1.10.1)':
+    dependencies:
+      '@connectrpc/connect': 1.4.0(@bufbuild/protobuf@1.10.1)
+      '@connectrpc/connect-node': 1.4.0(@bufbuild/protobuf@1.10.1)(@connectrpc/connect@1.4.0(@bufbuild/protobuf@1.10.1))
+      '@connectrpc/connect-web': 1.4.0(@bufbuild/protobuf@1.10.1)(@connectrpc/connect@1.4.0(@bufbuild/protobuf@1.10.1))
+      '@utxorpc/spec': 0.16.0
+      buffer: 6.0.3
+    transitivePeerDependencies:
+      - '@bufbuild/protobuf'
+
+  '@utxorpc/spec@0.16.0':
+    dependencies:
+      '@bufbuild/protobuf': 1.10.1
+
   '@vercel/build-utils@7.10.0': {}
 
   '@vercel/error-utils@2.0.2': {}
@@ -7821,7 +8903,7 @@ snapshots:
       - encoding
       - supports-color
 
-  '@vercel/node@3.0.25(@swc/core@1.4.17(@swc/helpers@0.5.2))(encoding@0.1.13)':
+  '@vercel/node@3.0.25(@swc/core@1.4.17)(encoding@0.1.13)':
     dependencies:
       '@edge-runtime/node-utils': 2.3.0
       '@edge-runtime/primitives': 4.1.0
@@ -7840,7 +8922,7 @@ snapshots:
       node-fetch: 2.6.9(encoding@0.1.13)
       path-to-regexp: 6.2.1
       ts-morph: 12.0.0
-      ts-node: 10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@14.18.33)(typescript@4.9.5)
+      ts-node: 10.9.1(@swc/core@1.4.17)(@types/node@14.18.33)(typescript@4.9.5)
       typescript: 4.9.5
       undici: 5.26.5
     transitivePeerDependencies:
@@ -8111,8 +9193,13 @@ snapshots:
 
   '@xtuc/long@4.2.2': {}
 
+  '@zxing/text-encoding@0.9.0':
+    optional: true
+
   abbrev@1.1.1: {}
 
+  abort-error@1.0.2: {}
+
   abortcontroller-polyfill@1.7.5: {}
 
   acorn-import-assertions@1.9.0(acorn@8.11.3):
@@ -8320,6 +9407,8 @@ snapshots:
     dependencies:
       has-symbols: 1.0.3
 
+  asynckit@0.4.0: {}
+
   atomically@2.0.2:
     dependencies:
       stubborn-fs: 1.2.5
@@ -8343,10 +9432,22 @@ snapshots:
 
   axe-core@4.7.0: {}
 
+  axios@1.19.0:
+    dependencies:
+      follow-redirects: 1.16.0
+      form-data: 4.0.6
+      https-proxy-agent: 5.0.1
+      proxy-from-env: 2.1.0
+    transitivePeerDependencies:
+      - debug
+      - supports-color
+
   axobject-query@3.2.1:
     dependencies:
       dequal: 2.0.3
 
+  b4a@1.8.1: {}
+
   bail@2.0.2: {}
 
   balanced-match@1.0.2: {}
@@ -8355,18 +9456,44 @@ snapshots:
     dependencies:
       safe-buffer: 5.2.1
 
+  base32-encoding@1.0.0: {}
+
   base64-js@1.5.1: {}
 
   bech32@2.0.0: {}
 
   bigint-mod-arith@3.3.1: {}
 
+  bignumber.js@9.3.1: {}
+
   binary-extensions@2.2.0: {}
 
   bindings@1.5.0:
     dependencies:
       file-uri-to-path: 1.0.0
 
+  bip39@3.1.0:
+    dependencies:
+      '@noble/hashes': 1.3.3
+
+  blake2b-wasm@2.4.0:
+    dependencies:
+      b4a: 1.8.1
+      nanoassert: 2.0.0
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  blake2b@2.1.4:
+    dependencies:
+      blake2b-wasm: 2.4.0
+      nanoassert: 2.0.0
+    transitivePeerDependencies:
+      - react-native-b4a
+
+  blakejs@1.2.1: {}
+
+  bn.js@5.2.5: {}
+
   boolbase@1.0.0: {}
 
   brace-expansion@1.1.11:
@@ -8408,6 +9535,11 @@ snapshots:
 
   cac@6.7.14: {}
 
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
   call-bind@1.0.7:
     dependencies:
       es-define-property: 1.0.0
@@ -8416,6 +9548,18 @@ snapshots:
       get-intrinsic: 1.2.4
       set-function-length: 1.2.1
 
+  call-bind@1.0.9:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      get-intrinsic: 1.3.0
+      set-function-length: 1.2.2
+
+  call-bound@1.0.4:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
   callsites@3.1.0: {}
 
   camelcase-css@2.0.1: {}
@@ -8430,10 +9574,28 @@ snapshots:
       multiformats: 13.1.0
       uint8arraylist: 2.4.8
 
+  cbor@10.0.12:
+    dependencies:
+      nofilter: 3.1.0
+
   cborg@4.2.0: {}
 
   ccount@2.0.1: {}
 
+  chacha-native@2.0.3:
+    dependencies:
+      bindings: 1.5.0
+      inherits: 2.0.4
+      nan: 2.28.0
+    optional: true
+
+  chacha@2.1.0:
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 1.1.14
+    optionalDependencies:
+      chacha-native: 2.0.3
+
   chai@4.4.1:
     dependencies:
       assertion-error: 1.1.0
@@ -8497,6 +9659,12 @@ snapshots:
 
   chrome-trace-event@1.0.3: {}
 
+  cipher-base@1.0.7:
+    dependencies:
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+      to-buffer: 1.2.2
+
   cjs-module-lexer@1.2.3: {}
 
   class-variance-authority@0.7.0:
@@ -8539,6 +9707,10 @@ snapshots:
       color-convert: 2.0.1
       color-string: 1.9.1
 
+  combined-stream@1.0.8:
+    dependencies:
+      delayed-stream: 1.0.0
+
   comma-separated-tokens@2.0.3: {}
 
   commander@2.20.3: {}
@@ -8568,6 +9740,8 @@ snapshots:
 
   convert-source-map@2.0.0: {}
 
+  core-util-is@1.0.3: {}
+
   cosmiconfig@9.0.0(typescript@5.3.3):
     dependencies:
       env-paths: 2.2.1
@@ -8577,8 +9751,31 @@ snapshots:
     optionalDependencies:
       typescript: 5.3.3
 
+  create-hash@1.2.0:
+    dependencies:
+      cipher-base: 1.0.7
+      inherits: 2.0.4
+      md5.js: 1.3.5
+      ripemd160: 2.0.3
+      sha.js: 2.4.12
+
+  create-hmac@1.1.7:
+    dependencies:
+      cipher-base: 1.0.7
+      create-hash: 1.2.0
+      inherits: 2.0.4
+      ripemd160: 2.0.3
+      safe-buffer: 5.2.1
+      sha.js: 2.4.12
+
   create-require@1.1.1: {}
 
+  cross-fetch@3.2.0(encoding@0.1.13):
+    dependencies:
+      node-fetch: 2.7.0(encoding@0.1.13)
+    transitivePeerDependencies:
+      - encoding
+
   cross-spawn@7.0.3:
     dependencies:
       path-key: 3.1.1
@@ -8670,6 +9867,8 @@ snapshots:
       has-property-descriptors: 1.0.2
       object-keys: 1.1.1
 
+  delayed-stream@1.0.0: {}
+
   delegates@1.0.0: {}
 
   depd@1.1.2: {}
@@ -8712,6 +9911,8 @@ snapshots:
       domhandler: 4.3.1
       entities: 2.2.0
 
+  dom-walk@0.1.2: {}
+
   domelementtype@2.3.0: {}
 
   domhandler@4.3.1:
@@ -8732,6 +9933,12 @@ snapshots:
 
   dotenv@7.0.0: {}
 
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
   eastasianwidth@0.2.0: {}
 
   edge-runtime@2.5.9:
@@ -8886,6 +10093,8 @@ snapshots:
     dependencies:
       get-intrinsic: 1.2.4
 
+  es-define-property@1.0.1: {}
+
   es-errors@1.3.0: {}
 
   es-iterator-helpers@1.0.17:
@@ -8912,12 +10121,23 @@ snapshots:
     dependencies:
       es-errors: 1.3.0
 
+  es-object-atoms@1.1.2:
+    dependencies:
+      es-errors: 1.3.0
+
   es-set-tostringtag@2.0.3:
     dependencies:
       get-intrinsic: 1.2.4
       has-tostringtag: 1.0.2
       hasown: 2.0.1
 
+  es-set-tostringtag@2.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.4
+
   es-shim-unscopables@1.0.2:
     dependencies:
       hasown: 2.0.1
@@ -9174,11 +10394,11 @@ snapshots:
       semver: 6.3.1
       string.prototype.matchall: 4.0.10
 
-  eslint-plugin-tailwindcss@3.15.1(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))):
+  eslint-plugin-tailwindcss@3.15.1(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))):
     dependencies:
       fast-glob: 3.3.2
       postcss: 8.4.38
-      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))
+      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))
 
   eslint-scope@5.1.1:
     dependencies:
@@ -9287,6 +10507,8 @@ snapshots:
 
   etag@1.8.1: {}
 
+  eventemitter3@5.0.4: {}
+
   events-intercept@2.0.0: {}
 
   events@3.3.0: {}
@@ -9362,19 +10584,35 @@ snapshots:
 
   flatted@3.3.1: {}
 
+  follow-redirects@1.16.0: {}
+
   for-each@0.3.3:
     dependencies:
       is-callable: 1.2.7
 
+  for-each@0.3.5:
+    dependencies:
+      is-callable: 1.2.7
+
   foreground-child@3.1.1:
     dependencies:
       cross-spawn: 7.0.3
       signal-exit: 4.1.0
 
+  form-data@4.0.6:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      es-set-tostringtag: 2.1.0
+      hasown: 2.0.4
+      mime-types: 2.1.35
+
   formdata-polyfill@4.0.10:
     dependencies:
       fetch-blob: 3.2.0
 
+  fraction.js@4.0.1: {}
+
   fraction.js@4.3.7: {}
 
   fs-extra@11.1.0:
@@ -9442,12 +10680,34 @@ snapshots:
       has-symbols: 1.0.3
       hasown: 2.0.1
 
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.2
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.4
+      math-intrinsics: 1.1.0
+
   get-iterator@1.0.2: {}
 
   get-nonce@1.0.1: {}
 
   get-port@4.2.0: {}
 
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.2
+
+  get-random-values@2.1.0:
+    dependencies:
+      global: 4.4.0
+
   get-stream@5.2.0:
     dependencies:
       pump: 3.0.0
@@ -9489,6 +10749,11 @@ snapshots:
       once: 1.4.0
       path-is-absolute: 1.0.1
 
+  global@4.4.0:
+    dependencies:
+      min-document: 2.19.2
+      process: 0.11.10
+
   globals@11.12.0: {}
 
   globals@13.24.0:
@@ -9512,6 +10777,8 @@ snapshots:
     dependencies:
       get-intrinsic: 1.2.4
 
+  gopd@1.2.0: {}
+
   graceful-fs@4.2.11: {}
 
   graphemer@1.4.0: {}
@@ -9530,12 +10797,28 @@ snapshots:
 
   has-symbols@1.0.3: {}
 
+  has-symbols@1.1.0: {}
+
   has-tostringtag@1.0.2:
     dependencies:
       has-symbols: 1.0.3
 
   has-unicode@2.0.1: {}
 
+  hash-base@3.1.2:
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 2.3.8
+      safe-buffer: 5.2.1
+      to-buffer: 1.2.2
+
+  hash.js@1.1.7:
+    dependencies:
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+
+  hashlru@2.3.0: {}
+
   hasown@2.0.1:
     dependencies:
       function-bind: 1.1.2
@@ -9544,6 +10827,10 @@ snapshots:
     dependencies:
       function-bind: 1.1.2
 
+  hasown@2.0.4:
+    dependencies:
+      function-bind: 1.1.2
+
   hast-util-to-estree@3.1.0:
     dependencies:
       '@types/estree': 1.0.5
@@ -9630,6 +10917,8 @@ snapshots:
 
   human-signals@1.1.1: {}
 
+  i@0.3.7: {}
+
   iconv-lite@0.4.24:
     dependencies:
       safer-buffer: 2.1.2
@@ -9672,6 +10961,13 @@ snapshots:
     dependencies:
       loose-envify: 1.4.0
 
+  ip-address@10.4.0: {}
+
+  ip-address@9.0.5:
+    dependencies:
+      jsbn: 1.1.0
+      sprintf-js: 1.1.3
+
   ipfs-utils@9.0.14(encoding@0.1.13):
     dependencies:
       any-signal: 3.0.1
@@ -9700,6 +10996,11 @@ snapshots:
       is-alphabetical: 2.0.1
       is-decimal: 2.0.1
 
+  is-arguments@1.2.0:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
   is-array-buffer@3.0.4:
     dependencies:
       call-bind: 1.0.7
@@ -9809,6 +11110,10 @@ snapshots:
     dependencies:
       which-typed-array: 1.1.14
 
+  is-typed-array@1.1.15:
+    dependencies:
+      which-typed-array: 1.1.22
+
   is-weakmap@2.0.1: {}
 
   is-weakref@1.0.2:
@@ -9822,12 +11127,18 @@ snapshots:
 
   isarray@0.0.1: {}
 
+  isarray@1.0.0: {}
+
   isarray@2.0.5: {}
 
   isexe@2.0.0: {}
 
   iso-url@1.2.1: {}
 
+  isomorphic-ws@4.0.1(ws@7.5.13):
+    dependencies:
+      ws: 7.5.13
+
   it-all@1.0.6: {}
 
   it-glob@1.0.2:
@@ -9872,8 +11183,14 @@ snapshots:
     dependencies:
       argparse: 2.0.1
 
+  jsbn@1.1.0: {}
+
   jsesc@2.5.2: {}
 
+  json-bigint@1.0.0:
+    dependencies:
+      bignumber.js: 9.3.1
+
   json-buffer@3.0.1: {}
 
   json-parse-even-better-errors@2.3.1: {}
@@ -9931,6 +11248,18 @@ snapshots:
       prelude-ls: 1.2.1
       type-check: 0.4.0
 
+  libsodium-sumo@0.7.16: {}
+
+  libsodium-sumo@0.8.4: {}
+
+  libsodium-wrappers-sumo@0.7.10:
+    dependencies:
+      libsodium-sumo: 0.7.16
+
+  libsodium-wrappers-sumo@0.8.4:
+    dependencies:
+      libsodium-sumo: 0.8.4
+
   lightningcss-darwin-arm64@1.24.1:
     optional: true
 
@@ -10009,6 +11338,8 @@ snapshots:
 
   lodash.merge@4.6.2: {}
 
+  lodash@4.18.1: {}
+
   long@5.2.3: {}
 
   longest-streak@3.1.0: {}
@@ -10031,21 +11362,14 @@ snapshots:
     dependencies:
       yallist: 4.0.0
 
-  lucid-cardano@0.10.10:
-    dependencies:
-      '@peculiar/webcrypto': 1.4.6
-      node-fetch: 3.3.2
-      ws: 8.16.0
-    transitivePeerDependencies:
-      - bufferutil
-      - utf-8-validate
-
   magic-bytes.js@1.10.0: {}
 
   magic-string@0.30.7:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.4.15
 
+  main-event@1.0.4: {}
+
   make-dir@3.1.0:
     dependencies:
       semver: 6.3.1
@@ -10054,6 +11378,14 @@ snapshots:
 
   markdown-extensions@2.0.0: {}
 
+  math-intrinsics@1.1.0: {}
+
+  md5.js@1.3.5:
+    dependencies:
+      hash-base: 3.1.2
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+
   mdast-util-from-markdown@2.0.0:
     dependencies:
       '@types/mdast': 4.0.3
@@ -10390,6 +11722,12 @@ snapshots:
 
   mimic-fn@4.0.0: {}
 
+  min-document@2.19.2:
+    dependencies:
+      dom-walk: 0.1.2
+
+  minimalistic-assert@1.0.1: {}
+
   minimatch@3.1.2:
     dependencies:
       brace-expansion: 1.1.11
@@ -10463,6 +11801,8 @@ snapshots:
 
   multiformats@13.1.0: {}
 
+  multiformats@14.0.5: {}
+
   murmurhash3js-revisited@3.0.0: {}
 
   mz@2.7.0:
@@ -10471,6 +11811,11 @@ snapshots:
       object-assign: 4.1.1
       thenify-all: 1.6.0
 
+  nan@2.28.0:
+    optional: true
+
+  nanoassert@2.0.0: {}
+
   nanoid@3.3.7: {}
 
   native-fetch@3.0.0(node-fetch@2.7.0(encoding@0.1.13)):
@@ -10553,6 +11898,8 @@ snapshots:
 
   node-releases@2.0.14: {}
 
+  nofilter@3.1.0: {}
+
   nopt@5.0.0:
     dependencies:
       abbrev: 1.1.1
@@ -10674,11 +12021,18 @@ snapshots:
     dependencies:
       p-limit: 3.1.0
 
+  p-queue@9.3.3:
+    dependencies:
+      eventemitter3: 5.0.4
+      p-timeout: 7.0.1
+
   p-retry@5.1.2:
     dependencies:
       '@types/retry': 0.12.1
       retry: 0.13.1
 
+  p-timeout@7.0.1: {}
+
   parcel@2.12.0(@swc/helpers@0.5.2)(postcss@8.4.38)(terser@5.29.1)(typescript@5.3.3):
     dependencies:
       '@parcel/config-default': 2.12.0(@parcel/core@2.12.0(@swc/helpers@0.5.2))(@swc/helpers@0.5.2)(postcss@8.4.38)(terser@5.29.1)(typescript@5.3.3)
@@ -10764,6 +12118,15 @@ snapshots:
 
   pathval@1.1.1: {}
 
+  pbkdf2@3.1.6:
+    dependencies:
+      create-hash: 1.2.0
+      create-hmac: 1.1.7
+      ripemd160: 2.0.3
+      safe-buffer: 5.2.1
+      sha.js: 2.4.12
+      to-buffer: 1.2.2
+
   pend@1.2.0: {}
 
   periscopic@3.1.0:
@@ -10800,13 +12163,13 @@ snapshots:
       camelcase-css: 2.0.1
       postcss: 8.4.38
 
-  postcss-load-config@4.0.2(postcss@8.4.38)(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)):
+  postcss-load-config@4.0.2(postcss@8.4.38)(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)):
     dependencies:
       lilconfig: 3.1.0
       yaml: 2.3.4
     optionalDependencies:
       postcss: 8.4.38
-      ts-node: 10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)
+      ts-node: 10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)
 
   postcss-nested@6.0.1(postcss@8.4.38):
     dependencies:
@@ -10874,6 +12237,12 @@ snapshots:
     dependencies:
       parse-ms: 2.1.0
 
+  process-nextick-args@2.0.1: {}
+
+  process@0.11.10: {}
+
+  progress-events@1.1.0: {}
+
   promisepipe@3.0.0: {}
 
   prop-types@15.8.1:
@@ -10899,6 +12268,8 @@ snapshots:
       '@types/node': 20.12.7
       long: 5.2.3
 
+  proxy-from-env@2.1.0: {}
+
   pump@3.0.0:
     dependencies:
       end-of-stream: 1.4.4
@@ -11003,6 +12374,23 @@ snapshots:
     dependencies:
       pify: 2.3.0
 
+  readable-stream@1.1.14:
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 0.0.1
+      string_decoder: 0.10.31
+
+  readable-stream@2.3.8:
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 1.0.0
+      process-nextick-args: 2.0.1
+      safe-buffer: 5.1.2
+      string_decoder: 1.1.1
+      util-deprecate: 1.0.2
+
   readable-stream@3.6.2:
     dependencies:
       inherits: 2.0.4
@@ -11090,6 +12478,11 @@ snapshots:
     dependencies:
       glob: 7.2.3
 
+  ripemd160@2.0.3:
+    dependencies:
+      hash-base: 3.1.2
+      inherits: 2.0.4
+
   rollup@4.11.0:
     dependencies:
       '@types/estree': 1.0.5
@@ -11113,6 +12506,10 @@ snapshots:
     dependencies:
       queue-microtask: 1.2.3
 
+  rxjs@7.8.2:
+    dependencies:
+      tslib: 2.6.2
+
   safe-array-concat@1.1.0:
     dependencies:
       call-bind: 1.0.7
@@ -11127,6 +12524,8 @@ snapshots:
       has-symbols: 1.0.3
       isarray: 2.0.5
 
+  safe-buffer@5.1.2: {}
+
   safe-buffer@5.2.1: {}
 
   safe-regex-test@1.0.3:
@@ -11137,6 +12536,10 @@ snapshots:
 
   safer-buffer@2.1.2: {}
 
+  scalus@0.14.2: {}
+
+  scalus@0.17.0: {}
+
   scheduler@0.23.2:
     dependencies:
       loose-envify: 1.4.0
@@ -11157,6 +12560,10 @@ snapshots:
     dependencies:
       lru-cache: 6.0.0
 
+  serialize-error@8.1.0:
+    dependencies:
+      type-fest: 0.20.2
+
   serialize-javascript@6.0.2:
     dependencies:
       randombytes: 2.1.0
@@ -11172,6 +12579,15 @@ snapshots:
       gopd: 1.0.1
       has-property-descriptors: 1.0.2
 
+  set-function-length@1.2.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.3.0
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+
   set-function-name@2.0.2:
     dependencies:
       define-data-property: 1.1.4
@@ -11181,6 +12597,12 @@ snapshots:
 
   setprototypeof@1.1.1: {}
 
+  sha.js@2.4.12:
+    dependencies:
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+      to-buffer: 1.2.2
+
   sharp@0.33.3:
     dependencies:
       color: 4.2.3
@@ -11254,6 +12676,8 @@ snapshots:
 
   space-separated-tokens@2.0.2: {}
 
+  sprintf-js@1.1.3: {}
+
   srcset@4.0.0: {}
 
   stable@0.1.8: {}
@@ -11343,6 +12767,12 @@ snapshots:
       define-properties: 1.2.1
       es-object-atoms: 1.0.0
 
+  string_decoder@0.10.31: {}
+
+  string_decoder@1.1.1:
+    dependencies:
+      safe-buffer: 5.1.2
+
   string_decoder@1.3.0:
     dependencies:
       safe-buffer: 5.2.1
@@ -11429,11 +12859,11 @@ snapshots:
     dependencies:
       '@babel/runtime': 7.24.4
 
-  tailwindcss-animate@1.0.7(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))):
+  tailwindcss-animate@1.0.7(tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))):
     dependencies:
-      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))
+      tailwindcss: 3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))
 
-  tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5)):
+  tailwindcss@3.4.3(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5)):
     dependencies:
       '@alloc/quick-lru': 5.2.0
       arg: 5.0.2
@@ -11452,7 +12882,7 @@ snapshots:
       postcss: 8.4.38
       postcss-import: 15.1.0(postcss@8.4.38)
       postcss-js: 4.0.1(postcss@8.4.38)
-      postcss-load-config: 4.0.2(postcss@8.4.38)(ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5))
+      postcss-load-config: 4.0.2(postcss@8.4.38)(ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5))
       postcss-nested: 6.0.1(postcss@8.4.38)
       postcss-selector-parser: 6.0.15
       resolve: 1.22.8
@@ -11483,14 +12913,14 @@ snapshots:
 
   term-size@2.2.1: {}
 
-  terser-webpack-plugin@5.3.10(@swc/core@1.4.17(@swc/helpers@0.5.2))(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2))):
+  terser-webpack-plugin@5.3.10(@swc/core@1.4.17)(webpack@5.90.3(@swc/core@1.4.17)):
     dependencies:
       '@jridgewell/trace-mapping': 0.3.22
       jest-worker: 27.5.1
       schema-utils: 3.3.0
       serialize-javascript: 6.0.2
       terser: 5.29.1
-      webpack: 5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2))
+      webpack: 5.90.3(@swc/core@1.4.17)
     optionalDependencies:
       '@swc/core': 1.4.17(@swc/helpers@0.5.2)
 
@@ -11523,6 +12953,12 @@ snapshots:
 
   tinyspy@2.2.1: {}
 
+  to-buffer@1.2.2:
+    dependencies:
+      isarray: 2.0.5
+      safe-buffer: 5.2.1
+      typed-array-buffer: 1.0.3
+
   to-fast-properties@2.0.0: {}
 
   to-regex-range@5.0.1:
@@ -11543,14 +12979,18 @@ snapshots:
     dependencies:
       typescript: 5.4.5
 
+  ts-custom-error@3.3.1: {}
+
   ts-interface-checker@0.1.13: {}
 
+  ts-log@2.2.7: {}
+
   ts-morph@12.0.0:
     dependencies:
       '@ts-morph/common': 0.11.1
       code-block-writer: 10.1.1
 
-  ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@14.18.33)(typescript@4.9.5):
+  ts-node@10.9.1(@swc/core@1.4.17)(@types/node@14.18.33)(typescript@4.9.5):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
       '@tsconfig/node10': 1.0.11
@@ -11570,7 +13010,7 @@ snapshots:
     optionalDependencies:
       '@swc/core': 1.4.17(@swc/helpers@0.5.2)
 
-  ts-node@10.9.1(@swc/core@1.4.17(@swc/helpers@0.5.2))(@types/node@20.12.7)(typescript@5.4.5):
+  ts-node@10.9.1(@swc/core@1.4.17)(@types/node@20.12.7)(typescript@5.4.5):
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
       '@tsconfig/node10': 1.0.11
@@ -11620,6 +13060,12 @@ snapshots:
       es-errors: 1.3.0
       is-typed-array: 1.1.13
 
+  typed-array-buffer@1.0.3:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-typed-array: 1.1.15
+
   typed-array-byte-length@1.0.1:
     dependencies:
       call-bind: 1.0.7
@@ -11669,10 +13115,24 @@ snapshots:
     dependencies:
       '@lukeed/csprng': 1.1.0
 
+  uint8-varint@2.0.5:
+    dependencies:
+      uint8arraylist: 2.4.8
+      uint8arrays: 5.0.3
+
+  uint8-varint@3.0.0:
+    dependencies:
+      uint8arraylist: 3.0.2
+      uint8arrays: 6.1.1
+
   uint8arraylist@2.4.8:
     dependencies:
       uint8arrays: 5.0.3
 
+  uint8arraylist@3.0.2:
+    dependencies:
+      uint8arrays: 6.1.1
+
   uint8arrays@4.0.10:
     dependencies:
       multiformats: 12.1.3
@@ -11681,6 +13141,10 @@ snapshots:
     dependencies:
       multiformats: 13.1.0
 
+  uint8arrays@6.1.1:
+    dependencies:
+      multiformats: 14.0.5
+
   unbox-primitive@1.0.2:
     dependencies:
       call-bind: 1.0.7
@@ -11694,6 +13158,10 @@ snapshots:
     dependencies:
       '@fastify/busboy': 2.1.1
 
+  undici@5.29.0:
+    dependencies:
+      '@fastify/busboy': 2.1.1
+
   unified@11.0.4:
     dependencies:
       '@types/unist': 3.0.2
@@ -11772,8 +13240,18 @@ snapshots:
       lodash.debounce: 4.0.8
       react: 18.3.1
 
+  utf8-codec@1.0.0: {}
+
   util-deprecate@1.0.2: {}
 
+  util@0.12.5:
+    dependencies:
+      inherits: 2.0.4
+      is-arguments: 1.2.0
+      is-generator-function: 1.0.10
+      is-typed-array: 1.1.13
+      which-typed-array: 1.1.15
+
   utility-types@3.11.0: {}
 
   uuid@3.3.2: {}
@@ -11793,14 +13271,14 @@ snapshots:
       - '@types/react'
       - '@types/react-dom'
 
-  vercel@33.6.2(@swc/core@1.4.17(@swc/helpers@0.5.2))(encoding@0.1.13):
+  vercel@33.6.2(@swc/core@1.4.17)(encoding@0.1.13):
     dependencies:
       '@vercel/build-utils': 7.10.0
       '@vercel/fun': 1.1.0(encoding@0.1.13)
       '@vercel/go': 3.0.5
       '@vercel/hydrogen': 1.0.2
       '@vercel/next': 4.1.6(encoding@0.1.13)
-      '@vercel/node': 3.0.25(@swc/core@1.4.17(@swc/helpers@0.5.2))(encoding@0.1.13)
+      '@vercel/node': 3.0.25(@swc/core@1.4.17)(encoding@0.1.13)
       '@vercel/python': 4.1.1
       '@vercel/redwood': 2.0.8(encoding@0.1.13)
       '@vercel/remix-builder': 2.1.5(encoding@0.1.13)
@@ -11897,6 +13375,12 @@ snapshots:
 
   weak-lru-cache@1.2.2: {}
 
+  web-encoding@1.1.5:
+    dependencies:
+      util: 0.12.5
+    optionalDependencies:
+      '@zxing/text-encoding': 0.9.0
+
   web-streams-polyfill@3.3.2: {}
 
   web-vitals@0.2.4: {}
@@ -11909,11 +13393,13 @@ snapshots:
       pvtsutils: 1.3.5
       tslib: 2.6.2
 
+  webextension-polyfill@0.8.0: {}
+
   webidl-conversions@3.0.1: {}
 
   webpack-sources@3.2.3: {}
 
-  webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2)):
+  webpack@5.90.3(@swc/core@1.4.17):
     dependencies:
       '@types/eslint-scope': 3.7.7
       '@types/estree': 1.0.5
@@ -11936,7 +13422,7 @@ snapshots:
       neo-async: 2.6.2
       schema-utils: 3.3.0
       tapable: 2.2.1
-      terser-webpack-plugin: 5.3.10(@swc/core@1.4.17(@swc/helpers@0.5.2))(webpack@5.90.3(@swc/core@1.4.17(@swc/helpers@0.5.2)))
+      terser-webpack-plugin: 5.3.10(@swc/core@1.4.17)(webpack@5.90.3(@swc/core@1.4.17))
       watchpack: 2.4.0
       webpack-sources: 3.2.3
     transitivePeerDependencies:
@@ -11997,6 +13483,16 @@ snapshots:
       gopd: 1.0.1
       has-tostringtag: 1.0.2
 
+  which-typed-array@1.1.22:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.9
+      call-bound: 1.0.4
+      for-each: 0.3.5
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+
   which@2.0.2:
     dependencies:
       isexe: 2.0.0
@@ -12024,6 +13520,8 @@ snapshots:
 
   wrappy@1.0.2: {}
 
+  ws@7.5.13: {}
+
   ws@8.16.0: {}
 
   xdg-app-paths@5.1.0:
diff --git a/web/app/collection/create/mint.tsx b/web/app/collection/create/mint.tsx
index c1e2071..acd6cf8 100644
--- a/web/app/collection/create/mint.tsx
+++ b/web/app/collection/create/mint.tsx
@@ -157,10 +157,10 @@ function MintButton({ status, setStatus }: MintStateProps) {
   const [policyId, setPolicyId] = useState('');
   const { prepareTx, uploadProgress } = useGenesisMint();
 
-  const { lucid, network } = useWallet();
+  const { mesh, network } = useWallet();
 
   const handleManage = useCallback(
-    () => router.push(`/collection/manage/${network.toLowerCase()}/${policyId}`),
+    () => router.push(`/collection/manage/${network}/${policyId}`),
     [router, policyId, network]
   );
 
@@ -190,38 +190,40 @@ function MintButton({ status, setStatus }: MintStateProps) {
     try {
       setStatus('preparing');
       const { tx, policyId } = await prepareTx();
-      const completed = await tx.complete();
+      const unsignedTx = await tx.complete();
 
       setPolicyId(policyId);
       setStatus('signing');
-      const signed = await timeout(
-        completed.sign().complete(),
+      if (!mesh?.wallet) {
+        throw Error('Wallet is not selected. Please reconnect a wallet');
+      }
+      const signedTx = await timeout(
+        mesh.wallet.signTx(unsignedTx),
         60 * 1000,
         'Timed out waiting for signature. Click mint to try again.'
       );
       // TODO: Show this tx hash during verification step
       const txHash = await timeout(
-        signed.submit(),
+        mesh.wallet.submitTx(signedTx),
         60 * 1000,
         'Timed out trying to submit transaction. Click mint to try again.'
       );
 
       setStatus('verifying');
-      if (lucid) {
-        // After 5 minutes something must have gone wrong. Hopefully suggesting a retry at this point is okay.
-        await timeout(
-          lucid.awaitTx(txHash),
-          5 * 60 * 1000,
-          'Timed out verifying transaction. Click mint to try again.'
-        );
-      }
+      const offchain = await import('@ikigai-github/mintun-offchain');
+      // After 5 minutes something must have gone wrong. Hopefully suggesting a retry at this point is okay.
+      await timeout(
+        offchain.awaitTx(mesh.provider, txHash),
+        5 * 60 * 1000,
+        'Timed out verifying transaction. Click mint to try again.'
+      );
 
       setStatus('complete');
     } catch (e: unknown) {
       notifyError(e);
       setStatus('ready');
     }
-  }, [prepareTx, lucid, setStatus]);
+  }, [prepareTx, mesh, setStatus]);
 
   useEffect(() => {
     if (status === 'ready') {
diff --git a/web/app/collection/create/use-genesis-mint.ts b/web/app/collection/create/use-genesis-mint.ts
index 210a4a6..fa554da 100644
--- a/web/app/collection/create/use-genesis-mint.ts
+++ b/web/app/collection/create/use-genesis-mint.ts
@@ -1,9 +1,8 @@
 'use client';
 
 import { useCallback, useMemo, useState } from 'react';
-import type { CollectionImage, ImagePurpose } from '@ikigai-github/mintun-offchain';
+import type { CollectionImage, ImagePurpose, MeshContext } from '@ikigai-github/mintun-offchain';
 import { getTime } from 'date-fns';
-import type { Lucid } from 'lucid-cardano';
 
 import { countImages } from '@/lib/image';
 import { createWebClient } from '@/lib/storage/client';
@@ -15,12 +14,15 @@ import { DataContract } from './schema';
 export default function useGenesisMint() {
   const [uploadProgress, setUploadProgress] = useState(0);
   const { contract, images, describe, social, traits, royalties } = useCreateCollectionContext();
-  const { lucid } = useWallet();
+  const { mesh } = useWallet();
   const numImages = useMemo(() => countImages(images), [images]);
 
   // Selects a random UTxO from the users wallet for use as the seed UTxO
-  const findSeed = useCallback(async (lucid: Lucid) => {
-    const utxos = await lucid.wallet.getUtxos();
+  const findSeed = useCallback(async (mesh: MeshContext) => {
+    if (!mesh.wallet) {
+      throw Error('Wallet is not selected. Please reconnect a wallet');
+    }
+    const utxos = await mesh.wallet.getUtxos();
     if (utxos.length === 0) {
       throw Error('Not enough funds in wallet to complete the mint');
     }
@@ -79,20 +81,20 @@ export default function useGenesisMint() {
   // Finds the seed, uploads images, and imports offchain in parallel. Then it builds the transaction.
   // It doesn't catch any thrown errors so higher level can manage that part.
   const prepareTx = useCallback(async () => {
-    if (!lucid) {
+    if (!mesh) {
       throw Error('Failed to connect to wallet API');
     }
 
-    if (!lucid.wallet) {
+    if (!mesh.wallet) {
       throw Error('Wallet is not selected. Please reconnect a wallet');
     }
 
-    const find = findSeed(lucid);
+    const find = findSeed(mesh);
     const upload = uploadImages();
     const offchain = import('@ikigai-github/mintun-offchain');
     const [seed, uploaded, { GenesisTxBuilder }] = await Promise.all([find, upload, offchain]);
 
-    const builder = GenesisTxBuilder.create(lucid).seed(seed).useCip88(true);
+    const builder = GenesisTxBuilder.create(mesh).seed(seed).useCip88(true);
 
     if (contract.maxTokens) {
       builder.maxNfts(+contract.maxTokens);
@@ -130,7 +132,7 @@ export default function useGenesisMint() {
     const policyId = cache.mint().policyId;
 
     return { tx, policyId };
-  }, [lucid, contract, describe, social, traits, royalties, findSeed, uploadImages]);
+  }, [mesh, contract, describe, social, traits, royalties, findSeed, uploadImages]);
 
   return {
     uploadProgress,
diff --git a/web/app/collection/manage/[network]/[policy]/context.tsx b/web/app/collection/manage/[network]/[policy]/context.tsx
index 4edde0e..4fadb0b 100644
--- a/web/app/collection/manage/[network]/[policy]/context.tsx
+++ b/web/app/collection/manage/[network]/[policy]/context.tsx
@@ -17,7 +17,7 @@ import type {
   RoyaltyRecipientType,
   ScriptCache,
 } from '@ikigai-github/mintun-offchain';
-import type { UTxO } from 'lucid-cardano';
+import type { UTxO } from '@meshsdk/core';
 import { useLocalStorage } from 'usehooks-ts';
 
 import { getErrorMessage, useWallet } from '@/lib/wallet';
@@ -96,18 +96,18 @@ export function ManageCollectionContextProvider(props: ManageCollectionContextPr
   const [minting, setMinting] = useState<MintunNft[]>([]);
   const [mintReferenceUtxo, setMintReferenceUtxo] = useState<UTxO | undefined>();
 
-  const { lucid } = useWallet();
+  const { mesh } = useWallet();
 
   const init = useCallback(async () => {
-    if (lucid) {
+    if (mesh) {
       setInitialized(false);
       setInitializing(true);
       try {
         const offchain = await import('@ikigai-github/mintun-offchain');
-        const { cache, state } = await offchain.ScriptCache.fromMintPolicyId(lucid, policy);
+        const { cache, state } = await offchain.ScriptCache.fromMintPolicyId(mesh, policy);
         const mintReferenceUtxo = await offchain.fetchMintingPolicyReferenceUtxo(cache);
         const info = await offchain.fetchCollectionInfo(cache);
-        const royalties = await offchain.extractRoyaltyInfo(lucid, policy);
+        const royalties = await offchain.extractRoyaltyInfo(mesh, policy);
         setRoyalties(royalties);
         setInfo(info);
         setState(state);
@@ -123,16 +123,16 @@ export function ManageCollectionContextProvider(props: ManageCollectionContextPr
         setInitializing(false);
       }
     }
-  }, [lucid, policy, setState, setCache, setInitialized, setInitializing, setMintReferenceUtxo]);
+  }, [mesh, policy, setState, setCache, setInitialized, setInitializing, setMintReferenceUtxo]);
 
   const syncCollectionNfts = useCallback(async () => {
-    if (lucid && state && cache) {
+    if (mesh && state && cache) {
       try {
         const offchain = await import('@ikigai-github/mintun-offchain');
         const address = state.info.nftValidatorAddress;
         if (address) {
-          const utxos = await offchain.fetchNftReferenceUtxos(lucid, cache.mint().policyId, address);
-          const minted = await Promise.all(utxos.map((utxo) => offchain.toNftData(lucid, utxo)));
+          const utxos = await offchain.fetchNftReferenceUtxos(mesh, cache.mint().policyId, address);
+          const minted = await Promise.all(utxos.map((utxo) => offchain.toNftData(utxo)));
 
           setNfts(minted);
         } else {
@@ -144,7 +144,7 @@ export function ManageCollectionContextProvider(props: ManageCollectionContextPr
         setError(getErrorMessage(error));
       }
     }
-  }, [lucid, state, cache, setNfts]);
+  }, [mesh, state, cache, setNfts]);
 
   useEffect(() => {
     if (!isInitialized) init();
diff --git a/web/app/collection/manage/[network]/[policy]/mint-drafts.tsx b/web/app/collection/manage/[network]/[policy]/mint-drafts.tsx
index 2d07b82..e4d60d5 100644
--- a/web/app/collection/manage/[network]/[policy]/mint-drafts.tsx
+++ b/web/app/collection/manage/[network]/[policy]/mint-drafts.tsx
@@ -22,7 +22,7 @@ export default function MintDrafts() {
     useManageCollectionContext();
   const [options, setOptions] = useState<DraftOption[]>([]);
 
-  const { lucid } = useWallet();
+  const { mesh } = useWallet();
 
   useEffect(() => {
     const sequence = state?.nextSequence || 0;
@@ -39,11 +39,11 @@ export default function MintDrafts() {
 
   const mintDrafts = useCallback(async () => {
     try {
-      if (!lucid) {
+      if (!mesh) {
         throw Error('Failed to connect to wallet API');
       }
 
-      if (!lucid.wallet) {
+      if (!mesh.wallet) {
         throw Error('Wallet is not selected. Please reconnect a wallet');
       }
 
@@ -94,7 +94,7 @@ export default function MintDrafts() {
 
       const offchain = await import('@ikigai-github/mintun-offchain');
 
-      const builder = offchain.MintTxBuilder.create(lucid);
+      const builder = offchain.MintTxBuilder.create(mesh);
 
       if (cache) {
         builder.cache(cache);
@@ -107,30 +107,34 @@ export default function MintDrafts() {
       }
 
       // TODO: Can add to ui to let them set the
-      const recipient = await lucid.wallet.address();
+      const recipient = await mesh.wallet.getChangeAddress();
 
       builder.nfts(nfts, recipient);
 
       const { tx, cache: newCache, state: nextState } = await builder.build();
 
-      const completed = await tx.complete();
+      const unsignedTx = await tx.complete();
 
       setStatus('signing');
 
-      const signed = await timeout(
-        completed.sign().complete(),
+      const signedTx = await timeout(
+        mesh.wallet.signTx(unsignedTx),
         60 * 1000,
         'Timed out waiting for signature. Please try again.'
       );
 
       const txHash = await timeout(
-        signed.submit(),
+        mesh.wallet.submitTx(signedTx),
         60 * 1000,
         'Timed out trying to submit transaction. Please try again.'
       );
 
       setStatus('verifying');
-      await timeout(lucid.awaitTx(txHash), 5 * 60 * 1000, 'Timed out verifying transaction. Please try again.');
+      await timeout(
+        offchain.awaitTx(mesh.provider, txHash),
+        5 * 60 * 1000,
+        'Timed out verifying transaction. Please try again.'
+      );
 
       setCache(newCache);
       setState(nextState);
@@ -142,7 +146,7 @@ export default function MintDrafts() {
       notifyError(e);
       setStatus('ready');
     }
-  }, [lucid, policy, cache, mintReferenceUtxo, setStatus, setCache, drafts, setState, setDrafts, options]);
+  }, [mesh, policy, cache, mintReferenceUtxo, setStatus, setCache, drafts, setState, setDrafts, options]);
 
   const onSelectToggle = useCallback(
     (index: number) => {
diff --git a/web/app/collection/manage/[network]/[policy]/store-minting-policy.tsx b/web/app/collection/manage/[network]/[policy]/store-minting-policy.tsx
index 5dd1c89..9a46c79 100644
--- a/web/app/collection/manage/[network]/[policy]/store-minting-policy.tsx
+++ b/web/app/collection/manage/[network]/[policy]/store-minting-policy.tsx
@@ -12,47 +12,51 @@ import { useManageCollectionContext } from './context';
 export default function StoreMintingPolicy() {
   const [status, setStatus] = useState<TransactionStatus>('ready');
   const { policy } = useManageCollectionContext();
-  const { lucid } = useWallet();
+  const { mesh } = useWallet();
 
   const storeMintingPolicy = useCallback(async () => {
     try {
-      if (!lucid) {
+      if (!mesh) {
         throw Error('Failed to connect to wallet API');
       }
 
-      if (!lucid.wallet) {
+      if (!mesh.wallet) {
         throw Error('Wallet is not selected. Please reconnect a wallet');
       }
 
       setStatus('preparing');
 
       const offchain = await import('@ikigai-github/mintun-offchain');
-      const { cache } = await offchain.ScriptCache.fromMintPolicyId(lucid, policy);
-      const tx = await offchain.createMintingPolicyReference(lucid, cache);
-      const completed = await tx.complete();
+      const { cache } = await offchain.ScriptCache.fromMintPolicyId(mesh, policy);
+      const tx = await offchain.createMintingPolicyReference(mesh, cache);
+      const unsignedTx = await tx.complete();
 
       setStatus('signing');
-      const signed = await timeout(
-        completed.sign().complete(),
+      const signedTx = await timeout(
+        mesh.wallet.signTx(unsignedTx),
         60 * 1000,
         'Timed out waiting for signature. Please try again.'
       );
 
       const txHash = await timeout(
-        signed.submit(),
+        mesh.wallet.submitTx(signedTx),
         60 * 1000,
         'Timed out trying to submit transaction. Please try again.'
       );
 
       setStatus('verifying');
-      await timeout(lucid.awaitTx(txHash), 5 * 60 * 1000, 'Timed out verifying transaction. Please try again.');
+      await timeout(
+        offchain.awaitTx(mesh.provider, txHash),
+        5 * 60 * 1000,
+        'Timed out verifying transaction. Please try again.'
+      );
 
       setStatus('complete');
     } catch (e: unknown) {
       notifyError(e);
       setStatus('ready');
     }
-  }, [lucid, policy, setStatus]);
+  }, [mesh, policy, setStatus]);
 
   useEffect(() => {
     if (status === 'complete') {
diff --git a/web/components/collections-list.tsx b/web/components/collections-list.tsx
index b6d6bda..db7088f 100644
--- a/web/components/collections-list.tsx
+++ b/web/components/collections-list.tsx
@@ -2,7 +2,7 @@
 
 import { useEffect, useState } from 'react';
 import Link from 'next/link';
-import { Network } from 'lucid-cardano';
+import { Network } from '@meshsdk/core';
 import { Img } from 'react-image';
 
 import { CollectionInfoExtended, getAllWalletCollections } from '@/lib/collection';
@@ -35,11 +35,11 @@ const CollectionCard = ({ info, network }: CollectionCardProps) => {
 
 export default function CollectionsList() {
   const [infos, setInfos] = useState<CollectionInfoExtended[]>([]);
-  const { lucid, isConnected, network } = useWallet();
+  const { mesh, isConnected, network } = useWallet();
 
   useEffect(() => {
-    if (isConnected && lucid) getAllWalletCollections(lucid).then((infos) => setInfos(infos));
-  }, [isConnected, lucid]);
+    if (isConnected && mesh) getAllWalletCollections(mesh).then((infos) => setInfos(infos));
+  }, [isConnected, mesh]);
 
   if (infos.length) {
     return (
diff --git a/web/components/wallet-provider.tsx b/web/components/wallet-provider.tsx
index 1b75b6e..110e956 100644
--- a/web/components/wallet-provider.tsx
+++ b/web/components/wallet-provider.tsx
@@ -1,10 +1,12 @@
 'use client';
 
 import { PropsWithChildren, useCallback, useEffect, useMemo, useState } from 'react';
-import type { Lucid, Network, WalletApi } from 'lucid-cardano';
+import type { MeshContext } from '@ikigai-github/mintun-offchain';
+import type { Network } from '@meshsdk/core';
 import { toast } from 'sonner';
 import { useLocalStorage } from 'usehooks-ts';
 
+import type { WalletApi } from '@/global';
 import {
   connect as connectInternal,
   disconnect as disconnectInternal,
@@ -15,14 +17,14 @@ import {
 } from '@/lib/wallet';
 
 export function WalletProvider({ children }: PropsWithChildren) {
-  const [lucid, setLucid] = useState<Lucid | null>(null);
+  const [mesh, setMesh] = useState<MeshContext | null>(null);
   const [api, setApi] = useState<WalletApi | null>(null);
   const [isInitializing, setInitializing] = useState(false);
   const [isInitialized, setInitialized] = useState(false);
   const [isEnabled, setEnabled] = useState(false);
   const [isConnecting, setConnecting] = useState(false);
   const [isConnected, setConnected] = useState(false);
-  const [network, setNetwork] = useState<Network>('Mainnet');
+  const [network, setNetwork] = useState<Network>('mainnet');
   const [selectedWallet, setSelectedWallet] = useState('');
   const [lastSelectedWallet, setLastSelectedWallet] = useLocalStorage('mintun:selected:wallet', '');
   const [changeAddress, setChangeAddress] = useState('');
@@ -32,7 +34,7 @@ export function WalletProvider({ children }: PropsWithChildren) {
 
   const setters: WalletContextSetters = useMemo(
     () => ({
-      setLucid,
+      setMesh,
       setApi,
       setInitializing,
       setInitialized,
@@ -48,7 +50,7 @@ export function WalletProvider({ children }: PropsWithChildren) {
       setAccountBalance,
     }),
     [
-      setLucid,
+      setMesh,
       setApi,
       setInitializing,
       setInitialized,
@@ -67,21 +69,21 @@ export function WalletProvider({ children }: PropsWithChildren) {
 
   const connect = useCallback(
     async (wallet: string) => {
-      if (lucid) {
-        await connectInternal(lucid, wallet, setters);
+      if (mesh) {
+        await connectInternal(mesh, wallet, setters);
       } else {
         await disconnectInternal(setters);
         toast.error('State was invalid while connecting. The state has been reset. Please try again.');
       }
     },
-    [lucid, setters]
+    [mesh, setters]
   );
 
   const disconnect = useCallback(() => disconnectInternal(setters), [setters]);
 
   const context: WalletContextType = useMemo(
     () => ({
-      lucid,
+      mesh,
       api,
       isInitializing,
       isInitialized,
@@ -99,7 +101,7 @@ export function WalletProvider({ children }: PropsWithChildren) {
       disconnect,
     }),
     [
-      lucid,
+      mesh,
       api,
       isInitializing,
       isInitialized,
diff --git a/web/lib/collection.ts b/web/lib/collection.ts
index 0d5ddad..e7a12dc 100644
--- a/web/lib/collection.ts
+++ b/web/lib/collection.ts
@@ -1,24 +1,27 @@
-import type { CollectionInfo } from '@ikigai-github/mintun-offchain';
-import type { Lucid } from 'lucid-cardano';
+import type { CollectionInfo, MeshContext } from '@ikigai-github/mintun-offchain';
 
-import { fetchTransactions } from './lucid/server';
+import { fetchTransactions } from './mesh/server';
 
 const ownerAssetName = '0006f0a000436f6c6c656374696f6e';
 const referenceAssetName = '000643b000436f6c6c656374696f6e';
 
 export type CollectionInfoExtended = CollectionInfo & { policyId: string; blockTime: number };
 
-export async function getAllWalletCollections(lucid: Lucid) {
+export async function getAllWalletCollections(mesh: MeshContext) {
+  if (!mesh.wallet) {
+    return [];
+  }
+
   const offchain = await import('@ikigai-github/mintun-offchain');
 
   let infos: CollectionInfoExtended[] = [];
   let units: string[] = [];
 
-  const utxos = await lucid.wallet.getUtxos();
+  const utxos = await mesh.wallet.getUtxos();
 
   // Switching owner with reference asset name
   utxos?.forEach((utxo) => {
-    const keys = Object.keys(utxo.assets);
+    const keys = utxo.output.amount.map((asset) => asset.unit);
     new Set([...keys]).forEach((key) => {
       if (key.endsWith(ownerAssetName)) {
         const unit = key.replace(ownerAssetName, referenceAssetName);
@@ -29,10 +32,13 @@ export async function getAllWalletCollections(lucid: Lucid) {
   await Promise.allSettled(
     units?.map(async (unit) => {
       try {
-        const transactions = await fetchTransactions(lucid.network, unit);
+        const transactions = await fetchTransactions(mesh.network, unit);
         const blockTime = transactions[0]?.block_time || 0;
-        const utxo = await lucid.utxoByUnit(unit);
-        const info = await offchain.extractCollectionInfo(lucid, utxo);
+        const utxo = await offchain.fetchUtxoByUnit(mesh.provider, unit);
+        if (!utxo) {
+          throw new Error(`Could not find utxo for unit: ${unit}`);
+        }
+        const info = await offchain.extractCollectionInfo(utxo);
         const policyId = unit.slice(0, 56);
         infos.push({ ...info, policyId, blockTime });
       } catch (err) {
diff --git a/web/lib/lucid/server.ts b/web/lib/mesh/server.ts
similarity index 69%
rename from web/lib/lucid/server.ts
rename to web/lib/mesh/server.ts
index ab8f427..b1c96c1 100644
--- a/web/lib/lucid/server.ts
+++ b/web/lib/mesh/server.ts
@@ -1,24 +1,25 @@
 // TODO: Running this stuff from server side doesn't work even with the lazy import
 //       Ideally would just replace lucid since it is no longer maintained.
 //       But that requires basically rewriting the offchain library so will wait till after MVP.
-import type { Network } from 'lucid-cardano';
+import type { MeshContext } from '@ikigai-github/mintun-offchain';
+import type { Network } from '@meshsdk/core';
 
-export async function createServerClient(network: Network) {
-  const { Lucid, Blockfrost } = await import('lucid-cardano');
-  const url = `https://cardano-${network.toLowerCase()}.blockfrost.io/api/v0`;
-  const key =
-    network.toLowerCase() === 'mainnet'
-      ? process.env.NEXT_PUBLIC_BLOCKFROST_KEY_MAINNET
-      : process.env.NEXT_PUBLIC_BLOCKFROST_KEY_PREPROD;
+function blockfrostProjectId(network: Network) {
+  return network === 'mainnet'
+    ? process.env.NEXT_PUBLIC_BLOCKFROST_KEY_MAINNET
+    : process.env.NEXT_PUBLIC_BLOCKFROST_KEY_PREPROD;
+}
 
-  const provider = new Blockfrost(url, key);
+export async function createServerContext(network: Network): Promise<MeshContext> {
+  const { BlockfrostProvider } = await import('@meshsdk/core');
+  const provider = new BlockfrostProvider(blockfrostProjectId(network) || '');
 
-  return await Lucid.new(provider, network);
+  return { provider, network };
 }
 
 function isNetwork(str: string): str is Network {
   const lower = str.toLowerCase();
-  return lower === 'mainnet' || lower === 'preprod' || lower === 'Preview';
+  return lower === 'mainnet' || lower === 'preprod' || lower === 'preview' || lower === 'testnet';
 }
 
 export async function fetchCollection(network: string, policyId: string) {
@@ -27,8 +28,8 @@ export async function fetchCollection(network: string, policyId: string) {
   }
 
   const offchain = await import('@ikigai-github/mintun-offchain');
-  const lucid = await createServerClient(network);
-  const { cache, state } = await offchain.ScriptCache.fromMintPolicyId(lucid, policyId);
+  const mesh = await createServerContext(network);
+  const { cache, state } = await offchain.ScriptCache.fromMintPolicyId(mesh, policyId);
   const mintReferenceUtxo = await offchain.fetchMintingPolicyReferenceUtxo(cache);
   const info = await offchain.fetchCollectionInfo(cache);
 
diff --git a/web/lib/wallet/connect.ts b/web/lib/wallet/connect.ts
index 72b024d..0af43c3 100644
--- a/web/lib/wallet/connect.ts
+++ b/web/lib/wallet/connect.ts
@@ -1,4 +1,5 @@
-import { type Lucid } from 'lucid-cardano';
+import type { MeshContext } from '@ikigai-github/mintun-offchain';
+import { BlockfrostProvider, BrowserWallet, type Network } from '@meshsdk/core';
 import { toast } from 'sonner';
 
 import { WalletContextSetters } from './context';
@@ -6,10 +7,15 @@ import { apiError } from './errors';
 import { waitforWalletExtension } from './util';
 import { getBalanceAda, getChangeAddress, getInstalledWalletExtensions, getStakeAddress, getWalletApi } from './wallet';
 
-async function createLucid() {
-  // TODO: Figure out if this is the best way to do this
-  const { Lucid } = await import('lucid-cardano');
-  return await Lucid.new(undefined, undefined);
+function blockfrostProviderFor(networkId: number) {
+  const projectId =
+    networkId === 1 ? process.env.NEXT_PUBLIC_BLOCKFROST_KEY_MAINNET : process.env.NEXT_PUBLIC_BLOCKFROST_KEY_PREPROD;
+  return new BlockfrostProvider(projectId || '');
+}
+
+// Default context before a wallet is connected and its actual network is known.
+function createMeshContext(): MeshContext {
+  return { provider: blockfrostProviderFor(0), network: 'preprod' };
 }
 
 export async function initWallet(lastSelectedWallet: string, setters: WalletContextSetters) {
@@ -30,16 +36,17 @@ export async function initWallet(lastSelectedWallet: string, setters: WalletCont
       }
     }
 
-    const lucid = await createLucid();
+    const mesh = createMeshContext();
 
     if (lastSelectedWallet) {
-      await connect(lucid, lastSelectedWallet, setters, true);
+      await connect(mesh, lastSelectedWallet, setters, true);
+    } else {
+      setters.setMesh(mesh);
     }
 
     // Should be all extensions have injected by now but could've waited longer
     const extensions = getInstalledWalletExtensions();
     setters.setInstalledExtensions(extensions);
-    setters.setLucid(lucid);
     setters.setInitialized(true);
   } finally {
     setters.setInitializing(false);
@@ -47,10 +54,7 @@ export async function initWallet(lastSelectedWallet: string, setters: WalletCont
 }
 
 export async function disconnect(setters: WalletContextSetters) {
-  // Only real way to fully clear state from lucid
-  const lucid = await createLucid();
-
-  setters.setLucid(lucid);
+  setters.setMesh(createMeshContext());
   setters.setApi(null);
   setters.setEnabled(false);
   setters.setConnecting(false);
@@ -62,7 +66,7 @@ export async function disconnect(setters: WalletContextSetters) {
   setters.setAccountBalance(0);
 }
 
-export async function connect(lucid: Lucid, wallet: string, setters: WalletContextSetters, suppressErrors = false) {
+export async function connect(mesh: MeshContext, wallet: string, setters: WalletContextSetters, suppressErrors = false) {
   setters.setConnecting(true);
   setters.setSelectedWallet(wallet);
 
@@ -70,15 +74,15 @@ export async function connect(lucid: Lucid, wallet: string, setters: WalletConte
   // for network and account changes. Add support for that.
   try {
     const api = await getWalletApi(wallet);
+    const browserWallet = await BrowserWallet.enable(wallet);
     const networkId = await api.getNetworkId();
-    await updateProvider(lucid, networkId, setters);
-
-    lucid.selectWallet(api);
-
-    api.getChangeAddress();
+    const network: Network = networkId === 1 ? 'mainnet' : 'preprod';
+    const provider = blockfrostProviderFor(networkId);
+    const newMesh: MeshContext = { provider, wallet: browserWallet, network };
 
     setters.setApi(api);
-    setters.setNetwork(networkId === 1 ? 'Mainnet' : 'Preprod');
+    setters.setMesh(newMesh);
+    setters.setNetwork(network);
     setters.setEnabled(true);
     setters.setConnected(true);
     setters.setLastSelectedWallet(wallet);
@@ -101,28 +105,3 @@ export async function connect(lucid: Lucid, wallet: string, setters: WalletConte
     }
   }
 }
-
-// Might make these completely different subdomains for ensuring not using the wrong wallet but
-// for now just will make clear which network the selected wallet is on in UI
-export async function updateProvider(lucid: Lucid, networkId: number, setters: WalletContextSetters) {
-  const { Blockfrost } = await import('lucid-cardano');
-  if (networkId === 1) {
-    if (lucid.network !== 'Mainnet' || !lucid.txBuilderConfig) {
-      const blockfrost = new Blockfrost(
-        'https://cardano-mainnet.blockfrost.io/api/v0',
-        process.env.NEXT_PUBLIC_BLOCKFROST_KEY_MAINNET
-      );
-      await lucid.switchProvider(blockfrost, 'Mainnet');
-      setters.setNetwork('Mainnet');
-    }
-  } else {
-    if (lucid.network !== 'Preprod' || !lucid.txBuilderConfig) {
-      const blockfrost = new Blockfrost(
-        'https://cardano-preprod.blockfrost.io/api/v0',
-        process.env.NEXT_PUBLIC_BLOCKFROST_KEY_PREPROD
-      );
-      await lucid.switchProvider(blockfrost, 'Preprod');
-      setters.setNetwork('Preprod');
-    }
-  }
-}
diff --git a/web/lib/wallet/context.ts b/web/lib/wallet/context.ts
index bf3c18e..2a0614a 100644
--- a/web/lib/wallet/context.ts
+++ b/web/lib/wallet/context.ts
@@ -1,10 +1,13 @@
 'use client';
 
 import { createContext, Dispatch, SetStateAction, useContext } from 'react';
-import type { Lucid, Network, WalletApi } from 'lucid-cardano';
+import type { MeshContext } from '@ikigai-github/mintun-offchain';
+import type { Network } from '@meshsdk/core';
+
+import type { WalletApi } from '@/global';
 
 export type WalletContextType = {
-  lucid: Lucid | null;
+  mesh: MeshContext | null;
   api: WalletApi | null;
   isInitializing: boolean;
   isInitialized: boolean;
@@ -23,7 +26,7 @@ export type WalletContextType = {
 };
 
 export type WalletContextSetters = {
-  setLucid: Dispatch<SetStateAction<Lucid | null>>;
+  setMesh: Dispatch<SetStateAction<MeshContext | null>>;
   setApi: Dispatch<SetStateAction<WalletApi | null>>;
   setInitializing: Dispatch<SetStateAction<boolean>>;
   setInitialized: Dispatch<SetStateAction<boolean>>;
@@ -42,14 +45,14 @@ export type WalletContextSetters = {
 const noop = async (..._: any) => {};
 
 export const WalletContext = createContext<WalletContextType>({
-  lucid: null,
+  mesh: null,
   api: null,
   isInitializing: false,
   isInitialized: false,
   isEnabled: false,
   isConnecting: false,
   isConnected: false,
-  network: 'Mainnet',
+  network: 'mainnet',
   selectedWallet: '',
   lastSelectedWallet: '',
   changeAddress: '',
diff --git a/web/next.config.mjs b/web/next.config.mjs
index dd354aa..f6d2ca3 100644
--- a/web/next.config.mjs
+++ b/web/next.config.mjs
@@ -3,15 +3,6 @@ import * as NextMdx from '@next/mdx';
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   swcMinify: true,
-  webpack: (config) => {
-    config.experiments = {
-      asyncWebAssembly: true,
-      topLevelAwait: true,
-      layers: true, // optional, with some bundlers/frameworks it doesn't work without
-    };
-
-    return config;
-  },
   images: {
     remotePatterns: [{ protocol: 'https', hostname: '**.w3s.link' }],
   },
diff --git a/web/package.json b/web/package.json
index a3dc82d..ed5b421 100644
--- a/web/package.json
+++ b/web/package.json
@@ -16,6 +16,7 @@
     "@ipld/dag-ucan": "^3.4.0",
     "@mdx-js/loader": "^3.0.1",
     "@mdx-js/react": "^3.0.1",
+    "@meshsdk/core": "^1.9.1",
     "@next/mdx": "^14.1.3",
     "@peculiar/webcrypto": "^1.4.6",
     "@radix-ui/react-accordion": "^1.1.2",
@@ -41,7 +42,6 @@
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.1.1",
     "date-fns": "^3.6.0",
-    "lucid-cardano": "^0.10.10",
     "magic-bytes.js": "^1.10.0",
     "next": "14.1.0",
     "next-themes": "^0.2.1",