@dynamic-labs-sdk/aleo 0.27.3 → 1.1.0

package/dist/walletStandard.esm.js

@@ -0,0 +1,409 @@
+import { a as MICROCREDITS_PER_CREDIT, c as version, o as AleoFeatureUnsupportedError, r as ALEO_MAINNET_NETWORK_ID, s as name, t as ALEO_NETWORK_TO_ID_MAP } from "./getNetworkByChainId-BaSjULzX.esm.js";
+import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
+import { assertWalletAccountSigningAvailability } from "@dynamic-labs-sdk/client";
+import { Network } from "@provablehq/aleo-types";
+import { WalletProviderPriority, assertDefined, createBaseNetworkProvider, formatWalletProviderGroupKey, formatWalletProviderKey, getAllProvidersFromWindow, getDefaultClient, getNetworkProviderBuilderRegistry, getWalletProviderRegistry, hasExtension, registerExtension } from "@dynamic-labs-sdk/client/core";
+import { WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
+import { ALEO_CHAINS, WalletDecryptPermission, WalletFeatureName } from "@provablehq/aleo-wallet-standard";
+
+//#region src/utils/formatMicrocreditsAsCredits/formatMicrocreditsAsCredits.ts
+const MICROCREDITS_PER_CREDIT_BIGINT = BigInt(MICROCREDITS_PER_CREDIT);
+const MICROCREDIT_DECIMAL_DIGITS = String(MICROCREDITS_PER_CREDIT).length - 1;
+/**
+* Bounded trailing-zero strip. `padStart` produces a fractional string
+* of exactly `MICROCREDIT_DECIMAL_DIGITS` characters, so the quantifier
+* upper bound matches the maximum possible run of trailing zeros —
+* keeps the regex linear and avoids the unbounded-quantifier hotspot.
+*/
+const TRAILING_ZEROS_PATTERN = /0{1,6}$/;
+/**
+* Format microcredits (bigint) as a decimal credits string without
+* losing precision for balances beyond `Number.MAX_SAFE_INTEGER`.
+*
+* The integer credits portion and the microcredits remainder are
+* computed in the bigint domain, then the remainder is zero-padded to
+* six digits and trailing fractional zeros are trimmed. Whole-credit
+* balances render without a redundant `.000000` suffix.
+*
+* @not-instrumented
+*/
+const formatMicrocreditsAsCredits = (microcredits) => {
+	const credits = microcredits / MICROCREDITS_PER_CREDIT_BIGINT;
+	const fractional = (microcredits % MICROCREDITS_PER_CREDIT_BIGINT).toString().padStart(MICROCREDIT_DECIMAL_DIGITS, "0").replace(TRAILING_ZEROS_PATTERN, "");
+	return fractional.length > 0 ? `${credits}.${fractional}` : `${credits}`;
+};
+
+//#endregion
+//#region src/utils/parseAleoMicrocreditsLiteral/parseAleoMicrocreditsLiteral.ts
+const U64_PRIVATE_SUFFIX = "u64.private";
+const U64_SUFFIX = "u64";
+/**
+* Parse an Aleo VM mapping plaintext literal into microcredits.
+*
+* Accepts the shapes the Aleo `account` mapping endpoint actually
+* emits — e.g. `1500000u64.private`, `1_500_000u64`, or a bare integer
+* wrapped in JSON quotes. Strips the trailing `u64` / `u64.private`
+* type suffix, surrounding quotes, and the cosmetic `_` group
+* separators Aleo plaintext literals allow.
+*
+* Returns `0n` for empty input and for any payload that doesn't parse
+* as an integer. `BigInt()` throws `SyntaxError` on anything that
+* isn't a parseable integer — a corrupted RPC response, a mid-flight
+* truncation, or an upstream API change could deliver such a payload,
+* and we'd rather show a zero balance than crash the network-provider
+* machinery with an unhandled rejection.
+*
+* @not-instrumented
+*/
+const parseAleoMicrocreditsLiteral = (raw) => {
+	let cleaned = raw.trim();
+	if (cleaned.startsWith("\"") && cleaned.endsWith("\"")) cleaned = cleaned.slice(1, -1);
+	if (cleaned.endsWith(U64_PRIVATE_SUFFIX)) cleaned = cleaned.slice(0, -11);
+	else if (cleaned.endsWith(U64_SUFFIX)) cleaned = cleaned.slice(0, -3);
+	cleaned = cleaned.split("_").join("").trim();
+	if (!cleaned) return BigInt(0);
+	try {
+		return BigInt(cleaned);
+	} catch {
+		return BigInt(0);
+	}
+};
+
+//#endregion
+//#region src/utils/fetchAleoBalance/fetchAleoBalance.ts
+/**
+* Aleo addresses are bech32-encoded — lowercase alphanumerics only — so we
+* can validate strictly. Refusing anything else before it reaches the URL
+* keeps `/`, `?`, `#`, `..`, etc. out of the request path (SSRF / path
+* injection defence).
+*/
+const ALEO_ADDRESS_PATTERN = /^aleo1[a-z0-9]{1,62}$/;
+/**
+* Fetches the public credits balance for an Aleo address by querying the
+* `account` mapping on `credits.aleo` via the network's HTTP RPC. Returns
+* the balance as a credits string (private records are not visible here —
+* they live on the wallet and require a connected adapter to enumerate).
+*
+* Returns `null` when the address is malformed or no RPC URL is
+* configured; returns `'0'` for any other failure mode (non-OK status,
+* empty body, `null` mapping, unparseable payload). This keeps the
+* function fail-soft for the network-provider machinery, which surfaces
+* the result directly to the UI.
+*
+* @not-instrumented
+*/
+const fetchAleoBalance = async ({ address, networkData }) => {
+	if (!ALEO_ADDRESS_PATTERN.test(address)) return null;
+	const baseUrl = networkData.rpcUrls.http[0];
+	if (!baseUrl) return null;
+	const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	const url = new URL(`program/credits.aleo/mapping/account/${encodeURIComponent(address)}`, base);
+	const response = await fetch(url.toString());
+	if (!response.ok) return "0";
+	const text = await response.text();
+	if (!text || text === "null") return "0";
+	const microcredits = parseAleoMicrocreditsLiteral(text);
+	if (microcredits <= BigInt(0)) return "0";
+	return formatMicrocreditsAsCredits(microcredits);
+};
+
+//#endregion
+//#region src/utils/createAleoNetworkProvider/createAleoNetworkProvider.ts
+/**
+* Build an `AleoNetworkProvider` bound to a specific `NetworkData`
+* (mainnet vs. testnet — anything the SDK config exposes). The provider
+* exposes a `getBalance({ address })` that proxies to
+* `fetchAleoBalance` over the configured RPC, returning public credits
+* only (private records require a connected wallet adapter).
+*
+* Called by `registerAleoNetworkProviderBuilder` — not invoked directly.
+*
+* @not-instrumented
+*/
+const createAleoNetworkProvider = (networkData) => ({
+	...createBaseNetworkProvider("ALEO", networkData),
+	getBalance: async ({ address }) => ({ balance: await fetchAleoBalance({
+		address,
+		networkData
+	}) })
+});
+
+//#endregion
+//#region src/registerAleoNetworkProviderBuilder/registerAleoNetworkProviderBuilder.ts
+/**
+* Register the Aleo network-provider builder on a Dynamic client.
+*
+* Wires `createAleoNetworkProvider` into the client's network-provider
+* builder registry under the `'ALEO'` chain key, which is how the SDK's
+* network machinery materializes a per-network provider on demand.
+* Idempotent — a second call is a no-op once the builder is registered.
+*
+* Internal: called by the Aleo extension entry points
+* (`addAleoWalletStandardExtension`, `addAleoWalletAdaptersExtension`,
+* `addAleoExtension`). Not exported from the package's public surface.
+*
+* @not-instrumented
+*/
+const registerAleoNetworkProviderBuilder = (client) => {
+	const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
+	if (networkProviderBuilderRegistry.get().get("ALEO")) return;
+	networkProviderBuilderRegistry.register({
+		builder: createAleoNetworkProvider,
+		chain: "ALEO"
+	});
+};
+
+//#endregion
+//#region src/walletStandard/aleoStandardWalletWindowKeys.ts
+/**
+* The `window` keys at which known Aleo Wallet Standard wallets inject
+* themselves. Scanned by `addAleoWalletStandardExtension` to discover
+* available wallets — analogous to EVM's hardcoded `'ethereum'` path in
+* `getEvmInjectedProviders`, or Tron's hardcoded adapter constructors
+* in `addTronWalletAdaptersExtension`.
+*
+* As new wallets adopt `@provablehq/aleo-wallet-standard`, add their
+* injection key here. Wallets that use the legacy adapter API
+* (`@provablehq/aleo-wallet-adaptor-core` — Leo, Puzzle, Fox, etc.) are
+* registered through `addAleoWalletAdaptersExtension` instead.
+*/
+const ALEO_STANDARD_WALLET_WINDOW_KEYS = ["shield"];
+
+//#endregion
+//#region src/utils/bytesToHex/bytesToHex.ts
+/**
+* Encode a `Uint8Array` as a lowercase hex string with no separator.
+* Used to render Aleo signature bytes for the `signMessage` provider
+* surface (which yields a hex `signature: string` per the Dynamic
+* `WalletProvider` contract) and any other place we need a stable
+* compact bytes-to-text encoding.
+*
+* @not-instrumented
+*/
+const bytesToHex = ({ bytes }) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+
+//#endregion
+//#region src/walletStandard/utils/aleoChainForChainId/aleoChainForChainId.ts
+/**
+* Inverse of `chainIdForAleoChain` — resolve the Aleo Wallet Standard
+* chain string for a Dynamic numeric chain id. Used by the
+* walletStandard provider's `switchActiveNetwork` to translate the
+* SDK's stringly-typed chain id into the wallet's expected `AleoChain`
+* value.
+*
+* @not-instrumented
+*/
+const aleoChainForChainId = ({ networkId }) => Number(networkId) === ALEO_MAINNET_NETWORK_ID ? ALEO_CHAINS.MAINNET : ALEO_CHAINS.TESTNET;
+
+//#endregion
+//#region src/walletStandard/utils/chainIdForAleoChain/chainIdForAleoChain.ts
+/**
+* Resolve the Dynamic numeric chain id for an Aleo Wallet Standard chain
+* string. `undefined` is treated as MAINNET to match
+* `createWalletProviderFromAleoStandardWallet`'s `connect()` default —
+* otherwise the SDK would report a different network than the one the
+* wallet was actually connected to.
+*
+* @not-instrumented
+*/
+const chainIdForAleoChain = ({ chain }) => {
+	if (chain === ALEO_CHAINS.MAINNET || chain === void 0) return String(ALEO_NETWORK_TO_ID_MAP[Network.MAINNET]);
+	return String(ALEO_NETWORK_TO_ID_MAP[Network.TESTNET]);
+};
+
+//#endregion
+//#region src/walletStandard/utils/normalizeAleoStandardWalletAccount/normalizeAleoStandardWalletAccount.ts
+/**
+* Reduce either string-form or object-form Aleo Wallet Standard
+* account entries to the bare address string the Dynamic SDK works
+* with.
+*
+* @not-instrumented
+*/
+const normalizeAleoStandardWalletAccount = ({ account }) => typeof account === "string" ? account : account.address;
+
+//#endregion
+//#region src/walletStandard/utils/createWalletProviderFromAleoStandardWallet/createWalletProviderFromAleoStandardWallet.ts
+/**
+* Translate an Aleo StandardWallet (feature-map API) into a Dynamic
+* `WalletProvider`. Unsupported features fall through as undefined methods
+* on the returned provider — callers should guard accordingly.
+*
+* @not-instrumented
+*/
+const createWalletProviderFromAleoStandardWallet = ({ dynamicClient, walletStandardWallet }) => {
+	const chain = "ALEO";
+	const displayName = walletStandardWallet.name;
+	const metadata = {
+		displayName,
+		icon: walletStandardWallet.icon ?? ""
+	};
+	const walletProviderType = WalletProviderEnum.BrowserExtension;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName,
+		walletProviderType
+	});
+	const connect = async () => {
+		const connectFeature = walletStandardWallet.features[WalletFeatureName.CONNECT];
+		if (!connectFeature?.available) throw new AleoFeatureUnsupportedError({
+			featureName: "connect",
+			walletName: displayName
+		});
+		const chainsFeature = walletStandardWallet.features[WalletFeatureName.CHAINS];
+		const initialChain = chainsFeature?.available && chainsFeature.chains[0] ? chainsFeature.chains[0] : ALEO_CHAINS.MAINNET;
+		await connectFeature.connect(initialChain, WalletDecryptPermission.UponRequest);
+		const accountsFeature = walletStandardWallet.features[WalletFeatureName.ACCOUNTS];
+		return { addresses: (accountsFeature?.available ? await accountsFeature.getAccounts() : []).map((account) => ({ address: normalizeAleoStandardWalletAccount({ account }) })) };
+	};
+	const destroy = async () => {
+		const connectFeature = walletStandardWallet.features[WalletFeatureName.CONNECT];
+		if (!connectFeature?.available) return;
+		try {
+			await connectFeature.disconnect();
+		} catch {}
+	};
+	const getActiveNetworkId = async () => {
+		const chainsFeature = walletStandardWallet.features[WalletFeatureName.CHAINS];
+		return { networkId: chainIdForAleoChain({ chain: chainsFeature?.available ? chainsFeature.chains[0] : void 0 }) };
+	};
+	const getConnectedAddresses = async () => {
+		const accountsFeature = walletStandardWallet.features[WalletFeatureName.ACCOUNTS];
+		if (!accountsFeature?.available) return { addresses: [] };
+		return { addresses: (await accountsFeature.getAccounts()).map((account) => normalizeAleoStandardWalletAccount({ account })) };
+	};
+	const signMessage = async ({ message, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const signFeature = walletStandardWallet.features[WalletFeatureName.SIGN];
+		if (!signFeature?.available) throw new AleoFeatureUnsupportedError({
+			featureName: "signMessage",
+			walletName: displayName
+		});
+		return { signature: bytesToHex({ bytes: await signFeature.signMessage(new TextEncoder().encode(message)) }) };
+	};
+	const switchActiveNetwork = async ({ networkId }) => {
+		const switchFeature = walletStandardWallet.features[WalletFeatureName.SWITCH_NETWORK];
+		if (!switchFeature?.available) throw new AleoFeatureUnsupportedError({
+			featureName: "switchNetwork",
+			walletName: displayName
+		});
+		const network = aleoChainForChainId({ networkId }) === ALEO_CHAINS.MAINNET ? Network.MAINNET : Network.TESTNET;
+		await switchFeature.switchNetwork(network);
+	};
+	const requestTransaction = async ({ transaction, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		await assertWalletAccountSigningAvailability({ walletAccount }, dynamicClient);
+		const executeFeature = walletStandardWallet.features[WalletFeatureName.EXECUTE];
+		if (!executeFeature?.available) throw new AleoFeatureUnsupportedError({
+			featureName: "executeTransaction",
+			walletName: displayName
+		});
+		const aleoTransaction = transaction;
+		const [transition] = aleoTransaction.transitions;
+		assertDefined(transition, "Transaction must have at least one transition");
+		const { transactionId } = await executeFeature.executeTransaction({
+			fee: aleoTransaction.fee,
+			function: transition.functionName,
+			inputs: transition.inputs,
+			privateFee: aleoTransaction.feePrivate,
+			program: transition.program
+		});
+		return { transactionId };
+	};
+	const decrypt = async ({ ciphertext, options, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		const decryptFeature = walletStandardWallet.features[WalletFeatureName.DECRYPT];
+		if (!decryptFeature?.available) throw new AleoFeatureUnsupportedError({
+			featureName: "decrypt",
+			walletName: displayName
+		});
+		return { plaintext: await decryptFeature.decrypt(ciphertext, options?.tpk, options?.programId, options?.functionName, options?.index) };
+	};
+	const requestRecords = async ({ program, options, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account not found");
+		const recordsFeature = walletStandardWallet.features[WalletFeatureName.REQUEST_RECORDS];
+		if (!recordsFeature?.available) throw new AleoFeatureUnsupportedError({
+			featureName: "requestRecords",
+			walletName: displayName
+		});
+		return { records: await recordsFeature.requestRecords(program, options?.plaintext ?? false) };
+	};
+	return {
+		chain,
+		connect,
+		decrypt,
+		destroy,
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: formatWalletProviderGroupKey(displayName),
+		key,
+		metadata,
+		requestRecords,
+		requestTransaction,
+		signMessage,
+		switchActiveNetwork,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/walletStandard/utils/isAleoStandardWallet/isAleoStandardWallet.ts
+/**
+* Type guard for an Aleo Wallet Standard wallet injected on the page —
+* checks the minimum shape we need (an object with a `features` map)
+* before we hand it to `createWalletProviderFromAleoStandardWallet`.
+*
+* Used to filter the candidate list returned by
+* `getAllProvidersFromWindow` (which can return anything sitting at the
+* configured window key, including the wallet's own `.providers`
+* sibling for EIP-5749-style multi-wallet injections).
+*
+* @not-instrumented
+*/
+const isAleoStandardWallet = (value) => typeof value === "object" && value !== null && "features" in value && typeof value.features === "object";
+
+//#endregion
+//#region src/walletStandard/addAleoWalletStandardExtension/addAleoWalletStandardExtension.ts
+const ALEO_WALLET_STANDARD_EXTENSION_KEY = "aleoWalletStandard";
+/**
+* Adds the Aleo Wallet Standard extension to the Dynamic client.
+*
+* Scans `window` at each of the known Aleo Wallet Standard injection
+* keys (see `ALEO_STANDARD_WALLET_WINDOW_KEYS`) via the shared
+* `getAllProvidersFromWindow` helper, wraps every found wallet as a
+* Dynamic `WalletProvider`, and registers it. The caller doesn't
+* enumerate wallets — same shape as EVM's
+* `addEvmWindowInjectedExtension` and Tron's
+* `addTronWalletAdaptersExtension`.
+*
+* @param [client] - The Dynamic client instance. Only required when
+*                   using multiple Dynamic clients.
+* @not-instrumented
+*/
+const addAleoWalletStandardExtension = (client = getDefaultClient()) => {
+	if (hasExtension({ extensionKey: ALEO_WALLET_STANDARD_EXTENSION_KEY }, client)) return;
+	registerExtension({ extensionKey: ALEO_WALLET_STANDARD_EXTENSION_KEY }, client);
+	registerAleoNetworkProviderBuilder(client);
+	const walletProviderRegistry = getWalletProviderRegistry(client);
+	ALEO_STANDARD_WALLET_WINDOW_KEYS.forEach((windowKey) => {
+		getAllProvidersFromWindow(windowKey).filter(isAleoStandardWallet).forEach((walletStandardWallet) => {
+			const walletProvider = createWalletProviderFromAleoStandardWallet({
+				dynamicClient: client,
+				walletStandardWallet
+			});
+			walletProviderRegistry.register({
+				priority: WalletProviderPriority.WINDOW_INJECT,
+				walletProvider
+			});
+		});
+	});
+};
+
+//#endregion
+//#region src/exports/walletStandard.ts
+assertPackageVersion(name, version);
+
+//#endregion
+export { ALEO_STANDARD_WALLET_WINDOW_KEYS, ALEO_WALLET_STANDARD_EXTENSION_KEY, addAleoWalletStandardExtension, createWalletProviderFromAleoStandardWallet };
+//# sourceMappingURL=walletStandard.esm.js.map

package/dist/walletStandard.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletStandard.esm.js","names":["ALEO_STANDARD_WALLET_WINDOW_KEYS: readonly string[]","chain: Chain","metadata: WalletProviderMetadata","connect: AleoWalletProvider['connect']","initialChain: AleoChain","destroy: AleoWalletProvider['destroy']","getActiveNetworkId: AleoWalletProvider['getActiveNetworkId']","getConnectedAddresses: AleoWalletProvider['getConnectedAddresses']","signMessage: AleoWalletProvider['signMessage']","switchActiveNetwork: AleoWalletProvider['switchActiveNetwork']","network: Network","requestTransaction: AleoWalletProvider['requestTransaction']","aleoTransaction: AleoTransaction","decrypt: AleoWalletProvider['decrypt']","requestRecords: AleoWalletProvider['requestRecords']","packageName","packageVersion"],"sources":["../src/utils/formatMicrocreditsAsCredits/formatMicrocreditsAsCredits.ts","../src/utils/parseAleoMicrocreditsLiteral/parseAleoMicrocreditsLiteral.ts","../src/utils/fetchAleoBalance/fetchAleoBalance.ts","../src/utils/createAleoNetworkProvider/createAleoNetworkProvider.ts","../src/registerAleoNetworkProviderBuilder/registerAleoNetworkProviderBuilder.ts","../src/walletStandard/aleoStandardWalletWindowKeys.ts","../src/utils/bytesToHex/bytesToHex.ts","../src/walletStandard/utils/aleoChainForChainId/aleoChainForChainId.ts","../src/walletStandard/utils/chainIdForAleoChain/chainIdForAleoChain.ts","../src/walletStandard/utils/normalizeAleoStandardWalletAccount/normalizeAleoStandardWalletAccount.ts","../src/walletStandard/utils/createWalletProviderFromAleoStandardWallet/createWalletProviderFromAleoStandardWallet.ts","../src/walletStandard/utils/isAleoStandardWallet/isAleoStandardWallet.ts","../src/walletStandard/addAleoWalletStandardExtension/addAleoWalletStandardExtension.ts","../src/exports/walletStandard.ts"],"sourcesContent":["import { MICROCREDITS_PER_CREDIT } from '../constants';\n\nconst MICROCREDITS_PER_CREDIT_BIGINT = BigInt(MICROCREDITS_PER_CREDIT);\nconst MICROCREDIT_DECIMAL_DIGITS = String(MICROCREDITS_PER_CREDIT).length - 1;\n\n/**\n * Bounded trailing-zero strip. `padStart` produces a fractional string\n * of exactly `MICROCREDIT_DECIMAL_DIGITS` characters, so the quantifier\n * upper bound matches the maximum possible run of trailing zeros —\n * keeps the regex linear and avoids the unbounded-quantifier hotspot.\n */\nconst TRAILING_ZEROS_PATTERN = /0{1,6}$/;\n\n/**\n * Format microcredits (bigint) as a decimal credits string without\n * losing precision for balances beyond `Number.MAX_SAFE_INTEGER`.\n *\n * The integer credits portion and the microcredits remainder are\n * computed in the bigint domain, then the remainder is zero-padded to\n * six digits and trailing fractional zeros are trimmed. Whole-credit\n * balances render without a redundant `.000000` suffix.\n *\n * @not-instrumented\n */\n// eslint-disable-next-line custom-rules/require-single-object-param -- single bigint arg; named-arg ceremony would not improve clarity\nexport const formatMicrocreditsAsCredits = (microcredits: bigint): string => {\n  const credits = microcredits / MICROCREDITS_PER_CREDIT_BIGINT;\n  const remainder = microcredits % MICROCREDITS_PER_CREDIT_BIGINT;\n  const fractional = remainder\n    .toString()\n    .padStart(MICROCREDIT_DECIMAL_DIGITS, '0')\n    .replace(TRAILING_ZEROS_PATTERN, '');\n  return fractional.length > 0 ? `${credits}.${fractional}` : `${credits}`;\n};\n","const U64_PRIVATE_SUFFIX = 'u64.private';\nconst U64_SUFFIX = 'u64';\n\n/**\n * Parse an Aleo VM mapping plaintext literal into microcredits.\n *\n * Accepts the shapes the Aleo `account` mapping endpoint actually\n * emits — e.g. `1500000u64.private`, `1_500_000u64`, or a bare integer\n * wrapped in JSON quotes. Strips the trailing `u64` / `u64.private`\n * type suffix, surrounding quotes, and the cosmetic `_` group\n * separators Aleo plaintext literals allow.\n *\n * Returns `0n` for empty input and for any payload that doesn't parse\n * as an integer. `BigInt()` throws `SyntaxError` on anything that\n * isn't a parseable integer — a corrupted RPC response, a mid-flight\n * truncation, or an upstream API change could deliver such a payload,\n * and we'd rather show a zero balance than crash the network-provider\n * machinery with an unhandled rejection.\n *\n * @not-instrumented\n */\n// eslint-disable-next-line custom-rules/require-single-object-param -- single string arg; named-arg ceremony would not improve clarity\nexport const parseAleoMicrocreditsLiteral = (raw: string): bigint => {\n  let cleaned = raw.trim();\n  if (cleaned.startsWith('\"') && cleaned.endsWith('\"')) {\n    cleaned = cleaned.slice(1, -1);\n  }\n  if (cleaned.endsWith(U64_PRIVATE_SUFFIX)) {\n    cleaned = cleaned.slice(0, -U64_PRIVATE_SUFFIX.length);\n  } else if (cleaned.endsWith(U64_SUFFIX)) {\n    cleaned = cleaned.slice(0, -U64_SUFFIX.length);\n  }\n  cleaned = cleaned.split('_').join('').trim();\n  if (!cleaned) return BigInt(0);\n  try {\n    return BigInt(cleaned);\n  } catch {\n    return BigInt(0);\n  }\n};\n","import type { NetworkData } from '@dynamic-labs-sdk/client';\n\nimport { formatMicrocreditsAsCredits } from '../formatMicrocreditsAsCredits';\nimport { parseAleoMicrocreditsLiteral } from '../parseAleoMicrocreditsLiteral';\n\ntype FetchAleoBalanceParams = {\n  address: string;\n  networkData: NetworkData;\n};\n\n/**\n * Aleo addresses are bech32-encoded — lowercase alphanumerics only — so we\n * can validate strictly. Refusing anything else before it reaches the URL\n * keeps `/`, `?`, `#`, `..`, etc. out of the request path (SSRF / path\n * injection defence).\n */\nconst ALEO_ADDRESS_PATTERN = /^aleo1[a-z0-9]{1,62}$/;\n\n/**\n * Fetches the public credits balance for an Aleo address by querying the\n * `account` mapping on `credits.aleo` via the network's HTTP RPC. Returns\n * the balance as a credits string (private records are not visible here —\n * they live on the wallet and require a connected adapter to enumerate).\n *\n * Returns `null` when the address is malformed or no RPC URL is\n * configured; returns `'0'` for any other failure mode (non-OK status,\n * empty body, `null` mapping, unparseable payload). This keeps the\n * function fail-soft for the network-provider machinery, which surfaces\n * the result directly to the UI.\n *\n * @not-instrumented\n */\nexport const fetchAleoBalance = async ({\n  address,\n  networkData,\n}: FetchAleoBalanceParams): Promise<string | null> => {\n  if (!ALEO_ADDRESS_PATTERN.test(address)) {\n    return null;\n  }\n\n  const baseUrl = networkData.rpcUrls.http[0];\n  if (!baseUrl) {\n    return null;\n  }\n\n  const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;\n  const url = new URL(\n    `program/credits.aleo/mapping/account/${encodeURIComponent(address)}`,\n    base\n  );\n  const response = await fetch(url.toString());\n  if (!response.ok) {\n    return '0';\n  }\n\n  const text = await response.text();\n  if (!text || text === 'null') {\n    return '0';\n  }\n\n  const microcredits = parseAleoMicrocreditsLiteral(text);\n  if (microcredits <= BigInt(0)) {\n    return '0';\n  }\n\n  return formatMicrocreditsAsCredits(microcredits);\n};\n","import type { NetworkData } from '@dynamic-labs-sdk/client';\nimport { createBaseNetworkProvider } from '@dynamic-labs-sdk/client/core';\n\nimport type { AleoNetworkProvider } from '../../AleoNetworkProvider.types';\nimport { fetchAleoBalance } from '../fetchAleoBalance';\n\n/**\n * Build an `AleoNetworkProvider` bound to a specific `NetworkData`\n * (mainnet vs. testnet — anything the SDK config exposes). The provider\n * exposes a `getBalance({ address })` that proxies to\n * `fetchAleoBalance` over the configured RPC, returning public credits\n * only (private records require a connected wallet adapter).\n *\n * Called by `registerAleoNetworkProviderBuilder` — not invoked directly.\n *\n * @not-instrumented\n */\n \nexport const createAleoNetworkProvider = (\n  networkData: NetworkData\n): AleoNetworkProvider => ({\n  ...createBaseNetworkProvider('ALEO', networkData),\n  getBalance: async ({ address }) => ({\n    balance: await fetchAleoBalance({\n      address,\n      networkData,\n    }),\n  }),\n});\n","import type { DynamicClient } from '@dynamic-labs-sdk/client';\nimport { getNetworkProviderBuilderRegistry } from '@dynamic-labs-sdk/client/core';\n\nimport { createAleoNetworkProvider } from '../utils/createAleoNetworkProvider';\n\n/**\n * Register the Aleo network-provider builder on a Dynamic client.\n *\n * Wires `createAleoNetworkProvider` into the client's network-provider\n * builder registry under the `'ALEO'` chain key, which is how the SDK's\n * network machinery materializes a per-network provider on demand.\n * Idempotent — a second call is a no-op once the builder is registered.\n *\n * Internal: called by the Aleo extension entry points\n * (`addAleoWalletStandardExtension`, `addAleoWalletAdaptersExtension`,\n * `addAleoExtension`). Not exported from the package's public surface.\n *\n * @not-instrumented\n */\nexport const registerAleoNetworkProviderBuilder = (\n  client: DynamicClient\n): void => {\n  const networkProviderBuilderRegistry =\n    getNetworkProviderBuilderRegistry(client);\n\n  if (networkProviderBuilderRegistry.get().get('ALEO')) {\n    return;\n  }\n\n  networkProviderBuilderRegistry.register({\n    builder: createAleoNetworkProvider,\n    chain: 'ALEO',\n  });\n};\n","/**\n * The `window` keys at which known Aleo Wallet Standard wallets inject\n * themselves. Scanned by `addAleoWalletStandardExtension` to discover\n * available wallets — analogous to EVM's hardcoded `'ethereum'` path in\n * `getEvmInjectedProviders`, or Tron's hardcoded adapter constructors\n * in `addTronWalletAdaptersExtension`.\n *\n * As new wallets adopt `@provablehq/aleo-wallet-standard`, add their\n * injection key here. Wallets that use the legacy adapter API\n * (`@provablehq/aleo-wallet-adaptor-core` — Leo, Puzzle, Fox, etc.) are\n * registered through `addAleoWalletAdaptersExtension` instead.\n */\nexport const ALEO_STANDARD_WALLET_WINDOW_KEYS: readonly string[] = ['shield'];\n","type BytesToHexParams = {\n  bytes: Uint8Array;\n};\n\n/**\n * Encode a `Uint8Array` as a lowercase hex string with no separator.\n * Used to render Aleo signature bytes for the `signMessage` provider\n * surface (which yields a hex `signature: string` per the Dynamic\n * `WalletProvider` contract) and any other place we need a stable\n * compact bytes-to-text encoding.\n *\n * @not-instrumented\n */\nexport const bytesToHex = ({ bytes }: BytesToHexParams): string =>\n  Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');\n","import {\n  ALEO_CHAINS,\n  type AleoChain,\n} from '@provablehq/aleo-wallet-standard';\n\nimport { ALEO_MAINNET_NETWORK_ID } from '../../../utils/constants';\n\ntype AleoChainForChainIdParams = {\n  /**\n   * The Dynamic numeric chain id, as a string. `'0'` is mainnet;\n   * anything else is treated as testnet.\n   */\n  networkId: string;\n};\n\n/**\n * Inverse of `chainIdForAleoChain` — resolve the Aleo Wallet Standard\n * chain string for a Dynamic numeric chain id. Used by the\n * walletStandard provider's `switchActiveNetwork` to translate the\n * SDK's stringly-typed chain id into the wallet's expected `AleoChain`\n * value.\n *\n * @not-instrumented\n */\nexport const aleoChainForChainId = ({\n  networkId,\n}: AleoChainForChainIdParams): AleoChain =>\n  Number(networkId) === ALEO_MAINNET_NETWORK_ID\n    ? (ALEO_CHAINS.MAINNET as AleoChain)\n    : (ALEO_CHAINS.TESTNET as AleoChain);\n","import { Network } from '@provablehq/aleo-types';\nimport {\n  ALEO_CHAINS,\n  type AleoChain,\n} from '@provablehq/aleo-wallet-standard';\n\nimport { ALEO_NETWORK_TO_ID_MAP } from '../../../utils/getNetworkByChainId';\n\ntype ChainIdForAleoChainParams = {\n  /**\n   * The Aleo Wallet Standard `AleoChain` string (`'aleo:mainnet'` /\n   * `'aleo:testnet'`), or `undefined` when the wallet exposed no\n   * CHAINS feature.\n   */\n  chain: AleoChain | undefined;\n};\n\n/**\n * Resolve the Dynamic numeric chain id for an Aleo Wallet Standard chain\n * string. `undefined` is treated as MAINNET to match\n * `createWalletProviderFromAleoStandardWallet`'s `connect()` default —\n * otherwise the SDK would report a different network than the one the\n * wallet was actually connected to.\n *\n * @not-instrumented\n */\nexport const chainIdForAleoChain = ({\n  chain,\n}: ChainIdForAleoChainParams): string => {\n  if (chain === ALEO_CHAINS.MAINNET || chain === undefined) {\n    return String(ALEO_NETWORK_TO_ID_MAP[Network.MAINNET]);\n  }\n  return String(ALEO_NETWORK_TO_ID_MAP[Network.TESTNET]);\n};\n","type NormalizeAleoStandardWalletAccountParams = {\n  /**\n   * An Aleo Wallet Standard account entry as returned by\n   * `wallet.features['standard:accounts'].getAccounts()`. Wallets may\n   * emit either a plain address string (older drafts of the spec) or a\n   * `{ address: string }` object (current spec) — this normalizer\n   * accepts both.\n   */\n  account: { address: string } | string;\n};\n\n/**\n * Reduce either string-form or object-form Aleo Wallet Standard\n * account entries to the bare address string the Dynamic SDK works\n * with.\n *\n * @not-instrumented\n */\nexport const normalizeAleoStandardWalletAccount = ({\n  account,\n}: NormalizeAleoStandardWalletAccountParams): string =>\n  typeof account === 'string' ? account : account.address;\n","import {\n  type Chain,\n  type DynamicClient,\n  type WalletProviderMetadata,\n  assertWalletAccountSigningAvailability,\n} from '@dynamic-labs-sdk/client';\nimport {\n  assertDefined,\n  formatWalletProviderGroupKey,\n  formatWalletProviderKey,\n} from '@dynamic-labs-sdk/client/core';\nimport { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';\nimport { Network } from '@provablehq/aleo-types';\nimport {\n  ALEO_CHAINS,\n  type AleoChain,\n  WalletDecryptPermission,\n  WalletFeatureName,\n} from '@provablehq/aleo-wallet-standard';\n\nimport type {\n  AleoTransaction,\n  AleoWalletProvider,\n} from '../../../AleoWalletProvider.types';\nimport { AleoFeatureUnsupportedError } from '../../../errors/AleoFeatureUnsupportedError';\nimport { bytesToHex } from '../../../utils/bytesToHex';\nimport type { TypedStandardWallet } from '../../AleoStandardWallet.types';\nimport { aleoChainForChainId } from '../aleoChainForChainId';\nimport { chainIdForAleoChain } from '../chainIdForAleoChain';\nimport { normalizeAleoStandardWalletAccount } from '../normalizeAleoStandardWalletAccount';\n\ntype CreateWalletProviderFromAleoStandardWalletParams = {\n  dynamicClient: DynamicClient;\n  walletStandardWallet: TypedStandardWallet;\n};\n\n/**\n * Translate an Aleo StandardWallet (feature-map API) into a Dynamic\n * `WalletProvider`. Unsupported features fall through as undefined methods\n * on the returned provider — callers should guard accordingly.\n *\n * @not-instrumented\n */\nexport const createWalletProviderFromAleoStandardWallet = ({\n  dynamicClient,\n  walletStandardWallet,\n}: CreateWalletProviderFromAleoStandardWalletParams): AleoWalletProvider => {\n  const chain: Chain = 'ALEO';\n\n  const displayName = walletStandardWallet.name;\n\n  const metadata: WalletProviderMetadata = {\n    displayName,\n    icon: walletStandardWallet.icon ?? '',\n  };\n\n  const walletProviderType = WalletProviderEnum.BrowserExtension;\n\n  const key = formatWalletProviderKey({\n    chain,\n    displayName,\n    walletProviderType,\n  });\n\n  const connect: AleoWalletProvider['connect'] = async () => {\n    const connectFeature =\n      walletStandardWallet.features[WalletFeatureName.CONNECT];\n    if (!connectFeature?.available) {\n      throw new AleoFeatureUnsupportedError({\n        featureName: 'connect',\n        walletName: displayName,\n      });\n    }\n\n    const chainsFeature =\n      walletStandardWallet.features[WalletFeatureName.CHAINS];\n    const initialChain: AleoChain =\n      chainsFeature?.available && chainsFeature.chains[0]\n        ? chainsFeature.chains[0]\n        : (ALEO_CHAINS.MAINNET as AleoChain);\n\n    await connectFeature.connect(\n      initialChain,\n      WalletDecryptPermission.UponRequest\n    );\n\n    const accountsFeature =\n      walletStandardWallet.features[WalletFeatureName.ACCOUNTS];\n    const rawAccounts = accountsFeature?.available\n      ? await accountsFeature.getAccounts()\n      : [];\n\n    return {\n      addresses: rawAccounts.map((account) => ({\n        address: normalizeAleoStandardWalletAccount({ account }),\n      })),\n    };\n  };\n\n  const destroy: AleoWalletProvider['destroy'] = async () => {\n    const connectFeature =\n      walletStandardWallet.features[WalletFeatureName.CONNECT];\n    if (!connectFeature?.available) {\n      return;\n    }\n    try {\n      await connectFeature.disconnect();\n    } catch {\n      // Best-effort: the wallet may already be disconnected, or the\n      // underlying call may fail for transient reasons. Per the\n      // WalletProvider contract, `destroy` should not block teardown\n      // on remote-signal errors.\n    }\n  };\n\n  const getActiveNetworkId: AleoWalletProvider['getActiveNetworkId'] =\n    async () => {\n      const chainsFeature =\n        walletStandardWallet.features[WalletFeatureName.CHAINS];\n      const activeChain = chainsFeature?.available\n        ? chainsFeature.chains[0]\n        : undefined;\n      return { networkId: chainIdForAleoChain({ chain: activeChain }) };\n    };\n\n  const getConnectedAddresses: AleoWalletProvider['getConnectedAddresses'] =\n    async () => {\n      const accountsFeature =\n        walletStandardWallet.features[WalletFeatureName.ACCOUNTS];\n      if (!accountsFeature?.available) {\n        return { addresses: [] };\n      }\n      const accounts = await accountsFeature.getAccounts();\n      return {\n        addresses: accounts.map((account) =>\n          normalizeAleoStandardWalletAccount({ account })\n        ),\n      };\n    };\n\n  const signMessage: AleoWalletProvider['signMessage'] = async ({\n    message,\n    walletAccount,\n  }) => {\n    assertDefined(walletAccount, 'Wallet account not found');\n    await assertWalletAccountSigningAvailability(\n      { walletAccount },\n      dynamicClient\n    );\n\n    const signFeature =\n      walletStandardWallet.features[WalletFeatureName.SIGN];\n    if (!signFeature?.available) {\n      throw new AleoFeatureUnsupportedError({\n        featureName: 'signMessage',\n        walletName: displayName,\n      });\n    }\n\n    const signatureBytes = await signFeature.signMessage(\n      new TextEncoder().encode(message)\n    );\n    return { signature: bytesToHex({ bytes: signatureBytes }) };\n  };\n\n  const switchActiveNetwork: AleoWalletProvider['switchActiveNetwork'] =\n    async ({ networkId }) => {\n      const switchFeature =\n        walletStandardWallet.features[WalletFeatureName.SWITCH_NETWORK];\n      if (!switchFeature?.available) {\n        throw new AleoFeatureUnsupportedError({\n          featureName: 'switchNetwork',\n          walletName: displayName,\n        });\n      }\n\n      const targetAleoChain = aleoChainForChainId({ networkId });\n      const network: Network =\n        targetAleoChain === ALEO_CHAINS.MAINNET\n          ? Network.MAINNET\n          : Network.TESTNET;\n      await switchFeature.switchNetwork(network);\n    };\n\n  const requestTransaction: AleoWalletProvider['requestTransaction'] = async ({\n    transaction,\n    walletAccount,\n  }) => {\n    assertDefined(walletAccount, 'Wallet account not found');\n    await assertWalletAccountSigningAvailability(\n      { walletAccount },\n      dynamicClient\n    );\n\n    const executeFeature =\n      walletStandardWallet.features[WalletFeatureName.EXECUTE];\n    if (!executeFeature?.available) {\n      throw new AleoFeatureUnsupportedError({\n        featureName: 'executeTransaction',\n        walletName: displayName,\n      });\n    }\n\n    const aleoTransaction: AleoTransaction = transaction;\n    const [transition] = aleoTransaction.transitions;\n    assertDefined(transition, 'Transaction must have at least one transition');\n\n    const { transactionId } = await executeFeature.executeTransaction({\n      fee: aleoTransaction.fee,\n      function: transition.functionName,\n      inputs: transition.inputs as string[],\n      privateFee: aleoTransaction.feePrivate,\n      program: transition.program,\n    });\n\n    return { transactionId };\n  };\n\n  const decrypt: AleoWalletProvider['decrypt'] = async ({\n    ciphertext,\n    options,\n    walletAccount,\n  }) => {\n    assertDefined(walletAccount, 'Wallet account not found');\n\n    const decryptFeature =\n      walletStandardWallet.features[WalletFeatureName.DECRYPT];\n    if (!decryptFeature?.available) {\n      throw new AleoFeatureUnsupportedError({\n        featureName: 'decrypt',\n        walletName: displayName,\n      });\n    }\n\n    const plaintext = await decryptFeature.decrypt(\n      ciphertext,\n      options?.tpk,\n      options?.programId,\n      options?.functionName,\n      options?.index\n    );\n    return { plaintext };\n  };\n\n  const requestRecords: AleoWalletProvider['requestRecords'] = async ({\n    program,\n    options,\n    walletAccount,\n  }) => {\n    assertDefined(walletAccount, 'Wallet account not found');\n\n    const recordsFeature =\n      walletStandardWallet.features[WalletFeatureName.REQUEST_RECORDS];\n    if (!recordsFeature?.available) {\n      throw new AleoFeatureUnsupportedError({\n        featureName: 'requestRecords',\n        walletName: displayName,\n      });\n    }\n\n    const records = await recordsFeature.requestRecords(\n      program,\n      options?.plaintext ?? false\n    );\n    return { records };\n  };\n\n  return {\n    chain,\n    connect,\n    decrypt,\n    destroy,\n    getActiveNetworkId,\n    getConnectedAddresses,\n    groupKey: formatWalletProviderGroupKey(displayName),\n    key,\n    metadata,\n    requestRecords,\n    requestTransaction,\n    signMessage,\n    switchActiveNetwork,\n    walletProviderType,\n  };\n};\n","import type { TypedStandardWallet } from '../../AleoStandardWallet.types';\n\n/**\n * Type guard for an Aleo Wallet Standard wallet injected on the page —\n * checks the minimum shape we need (an object with a `features` map)\n * before we hand it to `createWalletProviderFromAleoStandardWallet`.\n *\n * Used to filter the candidate list returned by\n * `getAllProvidersFromWindow` (which can return anything sitting at the\n * configured window key, including the wallet's own `.providers`\n * sibling for EIP-5749-style multi-wallet injections).\n *\n * @not-instrumented\n */\n \nexport const isAleoStandardWallet = (\n  value: unknown\n): value is TypedStandardWallet =>\n  typeof value === 'object' &&\n  value !== null &&\n  'features' in value &&\n  typeof (value as Record<string, unknown>).features === 'object';\n","import {\n  WalletProviderPriority,\n  getAllProvidersFromWindow,\n  getDefaultClient,\n  getWalletProviderRegistry,\n  hasExtension,\n  registerExtension,\n} from '@dynamic-labs-sdk/client/core';\n\nimport { registerAleoNetworkProviderBuilder } from '../../registerAleoNetworkProviderBuilder';\nimport { ALEO_STANDARD_WALLET_WINDOW_KEYS } from '../aleoStandardWalletWindowKeys';\nimport { createWalletProviderFromAleoStandardWallet } from '../utils/createWalletProviderFromAleoStandardWallet';\nimport { isAleoStandardWallet } from '../utils/isAleoStandardWallet';\n\nexport const ALEO_WALLET_STANDARD_EXTENSION_KEY = 'aleoWalletStandard';\n\n/**\n * Adds the Aleo Wallet Standard extension to the Dynamic client.\n *\n * Scans `window` at each of the known Aleo Wallet Standard injection\n * keys (see `ALEO_STANDARD_WALLET_WINDOW_KEYS`) via the shared\n * `getAllProvidersFromWindow` helper, wraps every found wallet as a\n * Dynamic `WalletProvider`, and registers it. The caller doesn't\n * enumerate wallets — same shape as EVM's\n * `addEvmWindowInjectedExtension` and Tron's\n * `addTronWalletAdaptersExtension`.\n *\n * @param [client] - The Dynamic client instance. Only required when\n *                   using multiple Dynamic clients.\n * @not-instrumented\n */\nexport const addAleoWalletStandardExtension = (\n  client = getDefaultClient()\n): void => {\n  if (\n    hasExtension({ extensionKey: ALEO_WALLET_STANDARD_EXTENSION_KEY }, client)\n  ) {\n    return;\n  }\n\n  registerExtension(\n    { extensionKey: ALEO_WALLET_STANDARD_EXTENSION_KEY },\n    client\n  );\n\n  registerAleoNetworkProviderBuilder(client);\n\n  const walletProviderRegistry = getWalletProviderRegistry(client);\n\n  ALEO_STANDARD_WALLET_WINDOW_KEYS.forEach((windowKey) => {\n    const candidates = getAllProvidersFromWindow<unknown>(windowKey);\n\n    candidates.filter(isAleoStandardWallet).forEach((walletStandardWallet) => {\n      const walletProvider = createWalletProviderFromAleoStandardWallet({\n        dynamicClient: client,\n        walletStandardWallet,\n      });\n\n      walletProviderRegistry.register({\n        priority: WalletProviderPriority.WINDOW_INJECT,\n        walletProvider,\n      });\n    });\n  });\n};\n","import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';\n\nimport {\n  name as packageName,\n  version as packageVersion,\n} from '../../package.json';\nassertPackageVersion(packageName, packageVersion);\n\nexport {\n  ALEO_WALLET_STANDARD_EXTENSION_KEY,\n  addAleoWalletStandardExtension,\n} from '../walletStandard/addAleoWalletStandardExtension';\nexport { ALEO_STANDARD_WALLET_WINDOW_KEYS } from '../walletStandard/aleoStandardWalletWindowKeys';\nexport { createWalletProviderFromAleoStandardWallet } from '../walletStandard/utils/createWalletProviderFromAleoStandardWallet';\nexport type { TypedStandardWallet } from '../walletStandard/AleoStandardWallet.types';\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs-sdk/aleo",
-  "version": "0.27.3",
+  "version": "1.1.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.esm.js",
@@ -14,16 +14,21 @@
       "types": "./dist/exports/index.d.ts",
       "import": "./dist/index.esm.js",
       "default": "./dist/index.cjs"
+    },
+    "./walletStandard": {
+      "types": "./dist/exports/walletStandard.d.ts",
+      "import": "./dist/walletStandard.esm.js",
+      "default": "./dist/walletStandard.cjs"
     }
   },
   "dependencies": {
-    "@dynamic-labs/sdk-api-core": "0.0.968",
+    "@dynamic-labs/sdk-api-core": "0.0.988",
     "@provablehq/aleo-types": "0.3.0-alpha.3",
     "@provablehq/aleo-wallet-adaptor-core": "0.3.0-alpha.3",
     "@provablehq/aleo-wallet-adaptor-shield": "0.3.0-alpha.3",
     "@provablehq/aleo-wallet-standard": "0.3.0-alpha.3",
-    "@dynamic-labs-sdk/assert-package-version": "0.27.3",
-    "@dynamic-labs-sdk/client": "0.27.3"
+    "@dynamic-labs-sdk/assert-package-version": "1.1.0",
+    "@dynamic-labs-sdk/client": "1.1.0"
   },
   "devDependencies": {
     "vitest": "2.1.9"