@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/in-memory-wallet-integration-CBRiPjLO.js

@@ -0,0 +1,130 @@
+import { a as __toESM } from "./rolldown-runtime-OvD0k9op.js";
+import "./_web-crypto-random-bytes-Bo-GTcRS.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./libsodium-wrappers-BhbOA8dQ.js";
+import "./codecs-Dc1Krpbt.js";
+import { t as SecretBox } from "./secret-box-DUR0ACYz.js";
+import "./safe-buffer-B_vMqJWU.js";
+import "./browser-B1eMbDwh.js";
+import { t as require_src } from "./src-BFoefPv_.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { n as createBlockchainNetworkTargetResolver, t as createAddAccounts } from "./create-add-accounts-Brqk84vF.js";
+import { g as MidnightNetworkId, h as supportedNetworkIds, s as MidnightSDKNetworkId } from "./const-D0CbQlo4.js";
+import { t as MidnightAccountId } from "./midnight-account-id.vo-DjCAGcqc.js";
+import { util } from "@laceio/cardano/key-management";
+import { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
+import { HDWallet, Roles } from "@midnightntwrk/wallet-sdk/hd";
+//#region ../../packages/module/midnight-sync/src/exported-modules/in-memory-wallet-integration/in-memory-wallet-integration-factory.ts
+init__polyfill_buffer_patch();
+var import_src = /* @__PURE__ */ __toESM(require_src());
+const deriveAndEncryptKey = async (hdWallet, derivationPath, password) => {
+	const derivationResult = hdWallet.selectAccount(derivationPath.accountIndex).selectRole(derivationPath.role).deriveKeyAt(derivationPath.index);
+	if (derivationResult.type !== "keyDerived") throw new Error(`Failed to derive a key (role ${derivationPath.role})`);
+	const keyHex = ByteArray(derivationResult.key);
+	return HexBytes.fromByteArray(ByteArray(await SecretBox.seal(keyHex, password)));
+};
+const createAccountData = async ({ accountIndex, networkId, password, seed, walletId, accountName }) => {
+	const generatedWallet = HDWallet.fromSeed(seed);
+	if (generatedWallet.type !== "seedOk") throw new Error("Failed to generate wallet from seed");
+	const zswapKeyDerivationPath = {
+		accountIndex,
+		index: 0,
+		role: Roles.Zswap
+	};
+	const encryptedZswapKey = await deriveAndEncryptKey(generatedWallet.hdWallet, zswapKeyDerivationPath, password);
+	const dustDerivationPath = {
+		accountIndex,
+		index: 0,
+		role: Roles.Dust
+	};
+	const encryptedDustKey = await deriveAndEncryptKey(generatedWallet.hdWallet, dustDerivationPath, password);
+	const nightExternalKeyDerivationPath = {
+		accountIndex,
+		index: 0,
+		role: Roles.NightExternal
+	};
+	const encryptedNightExternalKey = await deriveAndEncryptKey(generatedWallet.hdWallet, nightExternalKeyDerivationPath, password);
+	return {
+		walletId,
+		accountId: MidnightAccountId(walletId, accountIndex, networkId),
+		networkType: networkId === NetworkId.NetworkId.MainNet ? "mainnet" : "testnet",
+		blockchainNetworkId: MidnightNetworkId(networkId),
+		blockchainSpecific: {
+			accountIndex,
+			networkId,
+			nightExternalKey: {
+				derivationPath: nightExternalKeyDerivationPath,
+				encryptedKey: encryptedNightExternalKey
+			},
+			zswapKey: {
+				derivationPath: zswapKeyDerivationPath,
+				encryptedKey: encryptedZswapKey
+			},
+			dustKey: {
+				derivationPath: dustDerivationPath,
+				encryptedKey: encryptedDustKey
+			}
+		},
+		accountType: "InMemory",
+		blockchainName: "Midnight",
+		metadata: { name: accountName || `Midnight #${accountIndex}` }
+	};
+};
+const resolveTargetNetworks = createBlockchainNetworkTargetResolver(supportedNetworkIds, MidnightSDKNetworkId);
+const createAccounts = async ({ blockchainSpecific: { encryptedSeed }, walletId, accountIndex, password, accountName, targetNetworks }) => {
+	const targetSdkNetworkIds = resolveTargetNetworks(targetNetworks);
+	const seed = await SecretBox.open(import_buffer.Buffer.from(encryptedSeed, "hex"), password);
+	const accounts = await Promise.all(targetSdkNetworkIds.map(async (networkId) => createAccountData({
+		accountIndex,
+		networkId,
+		password,
+		seed,
+		walletId,
+		accountName
+	})));
+	seed.fill(0);
+	return accounts;
+};
+const initializeWallet = async (props, dependencies) => {
+	dependencies.logger.debug("Creating Midnight in-memory wallet");
+	if (!props.password) throw new Error("Midnight in-memory integration does not yet support lazy wallets (no password): the existing account shape requires encrypted per-role keys");
+	const { password } = props;
+	const blockchainSpecificWalletData = await createBlockchainSpecificWalletData({
+		...props,
+		password
+	}, dependencies);
+	return {
+		accounts: await createAccounts({
+			...props,
+			accountIndex: 0,
+			blockchainName: "Midnight",
+			blockchainSpecific: blockchainSpecificWalletData,
+			password
+		}, dependencies),
+		blockchainSpecificWalletData
+	};
+};
+const createBlockchainSpecificWalletData = async ({ password, recoveryPhrase }) => {
+	const seed = await import_src.mnemonicToSeed(util.joinMnemonicWords(recoveryPhrase));
+	try {
+		return { encryptedSeed: HexBytes.fromByteArray(ByteArray(await SecretBox.seal(seed, password))) };
+	} finally {
+		seed.fill(0);
+	}
+};
+const addAccounts = createAddAccounts({
+	blockchainName: "Midnight",
+	createAccounts,
+	createBlockchainSpecificWalletData
+});
+const createInMemoryWalletIntegration = () => ({
+	initializeWallet,
+	createAccounts,
+	addAccounts,
+	blockchainName: "Midnight"
+});
+//#endregion
+//#region ../../packages/module/midnight-sync/src/exported-modules/in-memory-wallet-integration/react-native.ts
+const inMemoryWalletIntegrationReactNative = createInMemoryWalletIntegration;
+//#endregion
+export { inMemoryWalletIntegrationReactNative };

package/dist/in-memory-wallet-integration-CULUB5Tf.cjs

@@ -0,0 +1,240 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+const require_secret_box = require("./secret-box-DrjLZuS1.cjs");
+require("./safe-buffer-DYOwEfHB.cjs");
+const require_bip32 = require("./bip32-D6wd_QMn.cjs");
+require("./pbkdf2-CIW-oWrm.cjs");
+const require_src$1 = require("./src-BDzYIksE.cjs");
+const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
+const require_create_add_accounts = require("./create-add-accounts-DzXIh7Ot.cjs");
+const require_const = require("./const-BsnjG2_Q.cjs");
+const require_midnight_account_id_vo = require("./midnight-account-id.vo-0x9X-r3l.cjs");
+let _laceio_cardano_key_management = require("@laceio/cardano/key-management");
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-hd/dist/HDWallet.js
+const Roles = {
+	NightExternal: 0,
+	NightInternal: 1,
+	Dust: 2,
+	Zswap: 3,
+	Metadata: 4
+};
+const PURPOSE = 44;
+const COIN_TYPE = 2400;
+const isValidChildIndex = (value) => Number.isSafeInteger(value) && value >= 0 && value < 2147483648;
+const CompositeDerivationResult = { fromResults: (results) => {
+	const { succeededKeys, failedRoles } = results.reduce((acc, result) => {
+		if (result.result.type === "keyDerived") acc.succeededKeys[result.role] = result.result.key;
+		else acc.failedRoles.push(result.role);
+		return acc;
+	}, {
+		succeededKeys: {},
+		failedRoles: []
+	});
+	if (failedRoles.length > 0) return {
+		type: "keyOutOfBounds",
+		roles: failedRoles
+	};
+	else return {
+		type: "keysDerived",
+		keys: succeededKeys
+	};
+} };
+var HDWallet = class HDWallet {
+	rootKey;
+	constructor(key) {
+		this.rootKey = key;
+	}
+	static fromSeed(seed) {
+		try {
+			return {
+				type: "seedOk",
+				hdWallet: new HDWallet(require_bip32.HDKey.fromMasterSeed(seed))
+			};
+		} catch (e) {
+			return {
+				type: "seedError",
+				error: e
+			};
+		}
+	}
+	selectAccount(account) {
+		return new AccountKey(this.rootKey, account);
+	}
+	/**
+	* Once all keys are derived - clear internals from private data, so that they do not reside in memory longer than
+	* needed.
+	*/
+	clear() {
+		this.rootKey.wipePrivateData();
+	}
+};
+var AccountKey = class {
+	rootKey;
+	account;
+	constructor(rootKey, account) {
+		this.account = account;
+		this.rootKey = rootKey;
+	}
+	selectRole(role) {
+		return new RoleKey(this.rootKey, this.account, role);
+	}
+	selectRoles(roles) {
+		return new CompositeRoleKey(this.rootKey, this.account, roles);
+	}
+};
+var RoleKey = class {
+	rootKey;
+	account;
+	role;
+	constructor(rootKey, account, role) {
+		this.role = role;
+		this.account = account;
+		this.rootKey = rootKey;
+	}
+	deriveKeyAt(index) {
+		if (![
+			this.account,
+			this.role,
+			index
+		].every(isValidChildIndex)) return { type: "keyOutOfBounds" };
+		const path = `m/${PURPOSE}'/${COIN_TYPE}'/${this.account}'/${this.role}/${index}`;
+		const derivedKey = this.rootKey.derive(path);
+		return derivedKey.privateKey ? {
+			type: "keyDerived",
+			key: derivedKey.privateKey
+		} : { type: "keyOutOfBounds" };
+	}
+};
+var CompositeRoleKey = class {
+	rootKey;
+	account;
+	roles;
+	constructor(rootKey, account, roles) {
+		this.roles = roles;
+		this.rootKey = rootKey;
+		this.account = account;
+	}
+	deriveKeysAt(index) {
+		const results = this.roles.map((role) => ({
+			role,
+			result: new RoleKey(this.rootKey, this.account, role).deriveKeyAt(index)
+		}));
+		return CompositeDerivationResult.fromResults(results);
+	}
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/exported-modules/in-memory-wallet-integration/in-memory-wallet-integration-factory.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_src = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_src$1.require_src());
+const deriveAndEncryptKey = async (hdWallet, derivationPath, password) => {
+	const derivationResult = hdWallet.selectAccount(derivationPath.accountIndex).selectRole(derivationPath.role).deriveKeyAt(derivationPath.index);
+	if (derivationResult.type !== "keyDerived") throw new Error(`Failed to derive a key (role ${derivationPath.role})`);
+	const keyHex = require_bytes_vo.ByteArray(derivationResult.key);
+	return require_bytes_vo.HexBytes.fromByteArray(require_bytes_vo.ByteArray(await require_secret_box.SecretBox.seal(keyHex, password)));
+};
+const createAccountData = async ({ accountIndex, networkId, password, seed, walletId, accountName }) => {
+	const generatedWallet = HDWallet.fromSeed(seed);
+	if (generatedWallet.type !== "seedOk") throw new Error("Failed to generate wallet from seed");
+	const zswapKeyDerivationPath = {
+		accountIndex,
+		index: 0,
+		role: Roles.Zswap
+	};
+	const encryptedZswapKey = await deriveAndEncryptKey(generatedWallet.hdWallet, zswapKeyDerivationPath, password);
+	const dustDerivationPath = {
+		accountIndex,
+		index: 0,
+		role: Roles.Dust
+	};
+	const encryptedDustKey = await deriveAndEncryptKey(generatedWallet.hdWallet, dustDerivationPath, password);
+	const nightExternalKeyDerivationPath = {
+		accountIndex,
+		index: 0,
+		role: Roles.NightExternal
+	};
+	const encryptedNightExternalKey = await deriveAndEncryptKey(generatedWallet.hdWallet, nightExternalKeyDerivationPath, password);
+	return {
+		walletId,
+		accountId: require_midnight_account_id_vo.MidnightAccountId(walletId, accountIndex, networkId),
+		networkType: networkId === require_const.NetworkId.MainNet ? "mainnet" : "testnet",
+		blockchainNetworkId: require_const.MidnightNetworkId(networkId),
+		blockchainSpecific: {
+			accountIndex,
+			networkId,
+			nightExternalKey: {
+				derivationPath: nightExternalKeyDerivationPath,
+				encryptedKey: encryptedNightExternalKey
+			},
+			zswapKey: {
+				derivationPath: zswapKeyDerivationPath,
+				encryptedKey: encryptedZswapKey
+			},
+			dustKey: {
+				derivationPath: dustDerivationPath,
+				encryptedKey: encryptedDustKey
+			}
+		},
+		accountType: "InMemory",
+		blockchainName: "Midnight",
+		metadata: { name: accountName || `Midnight #${accountIndex}` }
+	};
+};
+const resolveTargetNetworks = require_create_add_accounts.createBlockchainNetworkTargetResolver(require_const.supportedNetworkIds, require_const.MidnightSDKNetworkId);
+const createAccounts = async ({ blockchainSpecific: { encryptedSeed }, walletId, accountIndex, password, accountName, targetNetworks }) => {
+	const targetSdkNetworkIds = resolveTargetNetworks(targetNetworks);
+	const seed = await require_secret_box.SecretBox.open(require__polyfill_buffer_patch.import_buffer.Buffer.from(encryptedSeed, "hex"), password);
+	const accounts = await Promise.all(targetSdkNetworkIds.map(async (networkId) => createAccountData({
+		accountIndex,
+		networkId,
+		password,
+		seed,
+		walletId,
+		accountName
+	})));
+	seed.fill(0);
+	return accounts;
+};
+const initializeWallet = async (props, dependencies) => {
+	dependencies.logger.debug("Creating Midnight in-memory wallet");
+	if (!props.password) throw new Error("Midnight in-memory integration does not yet support lazy wallets (no password): the existing account shape requires encrypted per-role keys");
+	const { password } = props;
+	const blockchainSpecificWalletData = await createBlockchainSpecificWalletData({
+		...props,
+		password
+	}, dependencies);
+	return {
+		accounts: await createAccounts({
+			...props,
+			accountIndex: 0,
+			blockchainName: "Midnight",
+			blockchainSpecific: blockchainSpecificWalletData,
+			password
+		}, dependencies),
+		blockchainSpecificWalletData
+	};
+};
+const createBlockchainSpecificWalletData = async ({ password, recoveryPhrase }) => {
+	const seed = await import_src.mnemonicToSeed(_laceio_cardano_key_management.util.joinMnemonicWords(recoveryPhrase));
+	try {
+		return { encryptedSeed: require_bytes_vo.HexBytes.fromByteArray(require_bytes_vo.ByteArray(await require_secret_box.SecretBox.seal(seed, password))) };
+	} finally {
+		seed.fill(0);
+	}
+};
+const addAccounts = require_create_add_accounts.createAddAccounts({
+	blockchainName: "Midnight",
+	createAccounts,
+	createBlockchainSpecificWalletData
+});
+const createInMemoryWalletIntegration = () => ({
+	initializeWallet,
+	createAccounts,
+	addAccounts,
+	blockchainName: "Midnight"
+});
+//#endregion
+//#region ../../packages/module/midnight-sync/src/exported-modules/in-memory-wallet-integration/react-native.ts
+const inMemoryWalletIntegrationReactNative = createInMemoryWalletIntegration;
+//#endregion
+exports.inMemoryWalletIntegrationReactNative = inMemoryWalletIntegrationReactNative;

package/dist/{in-memory-wallet-integration-D-qn65Kx.js → in-memory-wallet-integration-ChIOirMW.js}

@@ -1,3 +1,6 @@
-import "./libsodium-wrappers-UH0LaOUE.js";
-import { a as inMemoryWalletIntegration, i as createLazyAccountsFromAccountPublicKey, n as createAccounts, o as initializeWallet, r as createBlockchainSpecificWalletData, t as addAccounts } from "./in-memory-wallet-integration-Croiuopx.js";
+import "./_web-crypto-random-bytes-Bo-GTcRS.js";
+import "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./libsodium-wrappers-BhbOA8dQ.js";
+import "./codecs-Dc1Krpbt.js";
+import { a as inMemoryWalletIntegration, i as createLazyAccountsFromAccountPublicKey, n as createAccounts, o as initializeWallet, r as createBlockchainSpecificWalletData, t as addAccounts } from "./in-memory-wallet-integration-CljprQQV.js";
 export { addAccounts, createAccounts, createBlockchainSpecificWalletData, createLazyAccountsFromAccountPublicKey, inMemoryWalletIntegration as default, initializeWallet };

package/dist/{in-memory-wallet-integration-Croiuopx.js → in-memory-wallet-integration-CljprQQV.js}

@@ -1,112 +1,15 @@
-import { n as import_buffer, r as init__polyfill_buffer_patch } from "./libsodium-wrappers-UH0LaOUE.js";
-import { n as HexBytes, r as SecretBox } from "./bytes.vo-TgiwogWF.js";
-import { t as CardanoNetworkId } from "./cardano-network-id.vo-CK1tNQDg.js";
-import { a as supportedNetworkIds, o as supportedNetworkMagics } from "./const-C84qHkjp.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+import { t as SecretBox } from "./secret-box-DUR0ACYz.js";
+import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
+import { n as createBlockchainNetworkTargetResolver, t as createAddAccounts } from "./create-add-accounts-Brqk84vF.js";
+import { t as CardanoNetworkId } from "./cardano-network-id.vo-Cfpvbod9.js";
+import { a as supportedNetworkIds, o as supportedNetworkMagics } from "./const-BJfIK_G-.js";
 import { InMemoryKeyAgent, KeyPurpose, util } from "@laceio/cardano/key-management";
 import * as Crypto from "@laceio/cardano/crypto";
 import { Cardano } from "@laceio/cardano/core";
-import { CustomError } from "ts-custom-error";
-//#region ../../packages/contract/network/src/resolve-blockchain-network-targets.ts
-/**
-* Returns a function that resolves an optional set of Lace
-* {@link BlockchainNetworkId} values to chain-specific representations using a
-* lookup map, with the same semantics as the in-memory wallet integrations:
-*
-* - `targets` undefined → all supported targets (the provided default list)
-* - empty set → throws
-* - non-empty set → each id must exist in the map or throws
-*/
-const createBlockchainNetworkTargetResolver = (supportedByBlockchainNetworkId, defaultForAllSupported) => (targets) => {
-	if (targets === void 0) return [...defaultForAllSupported];
-	if (targets.size === 0) throw new Error("Empty target networks");
-	return Array.from(targets, (id) => {
-		const resolved = supportedByBlockchainNetworkId.get(id);
-		if (resolved === void 0) throw new Error(`Invalid network id: ${id}`);
-		return resolved;
-	});
-};
-//#endregion
 //#region ../../packages/contract/cardano-context/src/value-objects/cardano-account-id.vo.ts
 const CardanoAccountId = (walletId, accountIndex, networkMagic) => `${walletId}-${accountIndex}-${networkMagic}`;
 //#endregion
-//#region ../../packages/contract/in-memory/src/create-add-accounts.ts
-init__polyfill_buffer_patch();
-/**
-* Thrown when adding an account on a new blockchain requires deriving a
-* root key from the mnemonic, but the wallet has none (Nami-imported).
-*/
-var RecoveryPhraseUnavailableError = class extends CustomError {
-	constructor() {
-		super("Cannot derive a new blockchain root key: this wallet has no mnemonic stored");
-	}
-};
-/**
-* Creates a type-safe function to get blockchain-specific data from a wallet.
-*/
-const createGetBlockchainData = (blockchainName) => (wallet) => {
-	return wallet.blockchainSpecific[blockchainName];
-};
-/**
-* Factory function that creates a standardized `addAccounts` implementation.
-*
-* Handles both scenarios:
-* - Existing blockchain: uses wallet's blockchainSpecific data to derive the accounts
-* - New blockchain: decrypts wallet's recoveryPhrase, creates blockchain data, creates accounts
-*
-* Returns a wallet with merged accounts and blockchainSpecific data.
-*
-* @example
-* ```typescript
-* export const addAccounts = createAddAccounts({
-*   blockchainName: 'Cardano',
-*   createAccounts,
-*   createBlockchainSpecificWalletData,
-* });
-* ```
-*/
-const createAddAccounts = ({ blockchainName, createAccounts, createBlockchainSpecificWalletData }) => {
-	const getBlockchainData = createGetBlockchainData(blockchainName);
-	return async (props, dependencies) => {
-		const { wallet, accountIndex, password, accountName, targetNetworks } = props;
-		let blockchainSpecificData = getBlockchainData(wallet);
-		let newBlockchainSpecificWalletData;
-		if (!blockchainSpecificData) {
-			if (!wallet.encryptedRecoveryPhrase) throw new RecoveryPhraseUnavailableError();
-			const recoveryPhraseBytes = await SecretBox.open(import_buffer.Buffer.from(wallet.encryptedRecoveryPhrase, "hex"), password);
-			const recoveryPhraseBuffer = import_buffer.Buffer.from(recoveryPhraseBytes);
-			try {
-				const recoveryPhrase = recoveryPhraseBuffer.toString("utf8").split(" ");
-				blockchainSpecificData = await createBlockchainSpecificWalletData({
-					walletId: wallet.walletId,
-					password,
-					recoveryPhrase
-				}, dependencies);
-				newBlockchainSpecificWalletData = blockchainSpecificData;
-			} finally {
-				recoveryPhraseBytes.fill(0);
-				recoveryPhraseBuffer.fill(0);
-			}
-		}
-		const newAccounts = await createAccounts({
-			blockchainSpecific: blockchainSpecificData,
-			accountIndex,
-			walletId: wallet.walletId,
-			blockchainName,
-			password,
-			accountName,
-			targetNetworks
-		}, dependencies);
-		return { wallet: {
-			...wallet,
-			accounts: [...wallet.accounts, ...newAccounts],
-			...newBlockchainSpecificWalletData && { blockchainSpecific: {
-				...wallet.blockchainSpecific,
-				[blockchainName]: newBlockchainSpecificWalletData
-			} }
-		} };
-	};
-};
-//#endregion
 //#region ../../packages/module/blockchain-cardano/src/in-memory-wallet-integration.ts
 init__polyfill_buffer_patch();
 const defaultAccountName = (accountIndex) => `Cardano #${accountIndex}`;
@@ -227,4 +130,4 @@ const inMemoryWalletIntegration = () => ({
 	blockchainName: "Cardano"
 });
 //#endregion
-export { inMemoryWalletIntegration as a, createLazyAccountsFromAccountPublicKey as i, createAccounts as n, initializeWallet as o, createBlockchainSpecificWalletData as r, addAccounts as t };
+export { inMemoryWalletIntegration as a, createLazyAccountsFromAccountPublicKey as i, createAccounts as n, initializeWallet as o, createBlockchainSpecificWalletData as r, CardanoAccountId as s, addAccounts as t };

package/dist/{in-memory-wallet-integration-DVh9sRXa.cjs → in-memory-wallet-integration-Cm6P8sk6.cjs}

@@ -1,6 +1,7 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-require("./_polyfill-buffer-patch-BnPVerlG.cjs");
-const require_in_memory_wallet_integration = require("./in-memory-wallet-integration-CnLYeX4-.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+const require_in_memory_wallet_integration = require("./in-memory-wallet-integration-t9I00R_V.cjs");
 exports.addAccounts = require_in_memory_wallet_integration.addAccounts;
 exports.createAccounts = require_in_memory_wallet_integration.createAccounts;
 exports.createBlockchainSpecificWalletData = require_in_memory_wallet_integration.createBlockchainSpecificWalletData;