@laceio/sdk 0.1.0 → 0.1.1-canary.1

package/dist/{in-memory-wallet-integration-CUTa68ET.js → in-memory-wallet-integration-BCOqDgbt.js}

@@ -1,113 +1,16 @@
-import "./chunk-D6g4UhsZ.js";
 import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
-import { t as SodiumBip32Ed25519 } from "./SodiumBip32Ed25519-BEfo1Q9m.js";
-import { r as NetworkMagics, t as ChainIds } from "./ChainId-CKbm87yQ.js";
-import { i as KeyPurpose } from "./types-B61DQoFW.js";
-import { a as HexBytes, o as SecretBox, r as deriveAccountPrivateKey, t as InMemoryKeyAgent } from "./InMemoryKeyAgent-D-3HejxN.js";
-import { t as CardanoNetworkId } from "./cardano-network-id.vo-CTYe-Oix.js";
-import { a as supportedNetworkIds, o as supportedNetworkMagics } from "./const-DeUA7zYl.js";
-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
+import { t as SodiumBip32Ed25519 } from "./SodiumBip32Ed25519-DCikAMsl.js";
+import { r as NetworkMagics, t as ChainIds } from "./ChainId-CeoG8Sov.js";
+import { i as KeyPurpose } from "./types-By-XeXWg.js";
+import { r as deriveAccountPrivateKey, t as InMemoryKeyAgent } from "./InMemoryKeyAgent-D8T3vtXy.js";
+import { t as SecretBox } from "./secret-box-CSmRp6Tt.js";
+import { n as HexBytes } from "./bytes.vo-CziaOsba.js";
+import { n as createBlockchainNetworkTargetResolver, t as createAddAccounts } from "./create-add-accounts-2mQA0ST2.js";
+import { t as CardanoNetworkId } from "./cardano-network-id.vo-CeLJqmb_.js";
+import { a as supportedNetworkIds, o as supportedNetworkMagics } from "./const-DbuUHSzR.js";
 //#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}`;
@@ -228,4 +131,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-Bi8I9Dso.js

@@ -0,0 +1,128 @@
+import { a as __toESM } from "./chunk-D6g4UhsZ.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
+import "./_web-crypto-random-bytes-BvzwTYPG.js";
+import "./safe-buffer-CqGpSFCQ.js";
+import "./browser-D5jRKv_L.js";
+import { t as require_src } from "./src-CgINPlSx.js";
+import { t as SecretBox } from "./secret-box-CSmRp6Tt.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { n as createBlockchainNetworkTargetResolver, t as createAddAccounts } from "./create-add-accounts-2mQA0ST2.js";
+import { t as joinMnemonicWords } from "./bip39-DZomfqeY.js";
+import { g as MidnightNetworkId, h as supportedNetworkIds, s as MidnightSDKNetworkId } from "./const-BB3MccLt.js";
+import { t as MidnightAccountId } from "./midnight-account-id.vo-BuB8fiVO.js";
+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(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-Bsl2ONua.cjs

@@ -0,0 +1,239 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+require("./pbkdf2-B1veireP.cjs");
+require("./safe-buffer-DbXbwhUQ.cjs");
+const require_src$1 = require("./src-BayYMIjw.cjs");
+const require_secret_box = require("./secret-box-ZfbYwBgS.cjs");
+const require_bip32 = require("./bip32-EPpcFrpH.cjs");
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_create_add_accounts = require("./create-add-accounts-B6mR2NMn.cjs");
+const require_bip39 = require("./bip39-MAck9iod.cjs");
+const require_const = require("./const-DgBzKfz6.cjs");
+const require_midnight_account_id_vo = require("./midnight-account-id.vo--Vcx34Xk.cjs");
+//#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_chunk.__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(require_bip39.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;