@laceio/sdk 0.1.1-canary.2 → 0.1.1

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

@@ -1,130 +0,0 @@
-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-BfEnY8fg.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-CoPx69lQ.cjs

@@ -1,240 +0,0 @@
-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-DLrX5SD9.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;