@dynamic-labs-sdk/client 1.28.0 → 1.30.0

package/dist/index.cjs

@@ -1,9 +1,9 @@
-const require_updateAuthFromVerifyResponse = require('./updateAuthFromVerifyResponse-DD_rZDrQ.cjs');
-const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-OhoRrL_X.cjs');
-const require_isDynamicWaasEnabled = require('./isDynamicWaasEnabled-DnDhv_Uj.cjs');
-const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-KCtF3oaO.cjs');
-const require_getWalletProviderByKey = require('./getWalletProviderByKey-CnpXHkmq.cjs');
-const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-BjRiou3K.cjs');
+const require_updateAuthFromVerifyResponse = require('./updateAuthFromVerifyResponse-Dvd40QfL.cjs');
+const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-wbWC24tw.cjs');
+const require_isDynamicWaasEnabled = require('./isDynamicWaasEnabled-BPEtdwZI.cjs');
+const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-CxIX-dC1.cjs');
+const require_getWalletProviderByKey = require('./getWalletProviderByKey-BapuuI8t.cjs');
+const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-DjZ5p_og.cjs');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
 let zod_mini = require("zod/mini");
@@ -407,6 +407,40 @@ var ClientAlreadyInitializedError = class extends require_updateAuthFromVerifyRe
 	}
 };
 
+//#endregion
+//#region src/modules/initializeClient/logoutIfSessionPublicKeyMismatched/logoutIfSessionPublicKeyMismatched.ts
+/**
+* Signs the user out when the local session key no longer matches the
+* `sessionPublicKey` claim carried by the current token.
+*
+* The claim is captured once at sign-in and carried forward unchanged on
+* every token refresh (it is not re-derived from the client's current
+* session key). If the local session key is regenerated afterwards — e.g. a
+* re-init racing a token refresh, or storage being partially cleared — every
+* subsequent request keeps signing with the new key while asserting the
+* stale claim, and is rejected server-side with `invalid_nonce_signature`
+* forever, since retrying never re-syncs the claim. Signing out forces a
+* fresh sign-in, which is the only flow that re-captures the claim from the
+* client's current key.
+* @notInstrumented
+*/
+const logoutIfSessionPublicKeyMismatched = async (client) => {
+	const core = require_updateAuthFromVerifyResponse.getCore(client);
+	const { sessionKeys, token } = core.state.get();
+	if (!sessionKeys || !token) return;
+	let tokenSessionPublicKey;
+	try {
+		({sessionPublicKey: tokenSessionPublicKey} = require_updateAuthFromVerifyResponse.decodeJwt(token));
+	} catch (error) {
+		core.logger.error("[logoutIfSessionPublicKeyMismatched] Failed to decode token", error);
+		return;
+	}
+	if (tokenSessionPublicKey && tokenSessionPublicKey !== sessionKeys) {
+		core.logger.error("[logoutIfSessionPublicKeyMismatched] Session key does not match token claim");
+		await require_updateAuthFromVerifyResponse.__logoutWithReason_wrapped({ reason: "session-public-key-mismatch" }, client);
+	}
+};
+
 //#endregion
 //#region src/modules/initializeClient/initializeClient.ts
 /**
@@ -460,6 +494,7 @@ const initializeClient = async (client = require_updateAuthFromVerifyResponse.ge
 			storage: core.storage
 		}).catch(() => require_updateAuthFromVerifyResponse.__logoutWithReason_wrapped({ reason: "keychain-migration-failed" }, client));
 		if (core.state.get().sessionKeys && !await core.keychain.hasKey("session")) await require_updateAuthFromVerifyResponse.__logoutWithReason_wrapped({ reason: "keychain-key-missing" }, client);
+		await logoutIfSessionPublicKeyMismatched(client);
 	}).then(async () => {
 		if (!core.state.get().projectSettings) await require_updateAuthFromVerifyResponse.fetchProjectSettings(client);
 	});
@@ -1587,6 +1622,38 @@ var NoWebAuthNSupportError = class extends require_updateAuthFromVerifyResponse.
 	}
 };
 
+//#endregion
+//#region src/errors/ScreeningNotRequiredError.ts
+/**
+* Thrown when screening is requested for a Dynamic embedded wallet, which is
+* already screened server-side during the signing ceremony.
+*
+* @example
+* ```ts
+* try {
+*   await screenSolanaTransactions({ transactions, walletAccount });
+* } catch (error) {
+*   if (error instanceof ScreeningNotRequiredError) {
+*     // Already covered server-side — go straight to signing.
+*   }
+* }
+* ```
+*
+* @see screenTransaction
+* @see isExternalWalletScreeningEnabled
+*/
+var ScreeningNotRequiredError = class extends require_updateAuthFromVerifyResponse.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "screening_not_required",
+			docsUrl: null,
+			name: "ScreeningNotRequiredError",
+			shortMessage: "Dynamic embedded wallets are screened during signing; screening them again is redundant"
+		});
+	}
+};
+
 //#endregion
 //#region src/errors/SimulationFailedError.ts
 var SimulationFailedError = class extends require_updateAuthFromVerifyResponse.BaseError {
@@ -8808,6 +8875,39 @@ const isHardwareWalletAccount = ({ walletAccount }) => walletAccount.hardwareWal
 */
 const isAnyWalletAccountConnected = (client = require_updateAuthFromVerifyResponse.getDefaultClient()) => require_updateAuthFromVerifyResponse.getWalletAccounts(client).length > 0;
 
+//#endregion
+//#region src/modules/wallets/isExternalWalletScreeningEnabled/isExternalWalletScreeningEnabled.ts
+/**
+* Checks whether the environment expects connected-wallet transactions to be
+* screened for sanctions before signing.
+*
+* @example
+* ```ts
+* if (isExternalWalletScreeningEnabled()) {
+*   const { decision } = await screenTransaction({
+*     chain: 'EVM',
+*     context: { evmTransaction: { to } },
+*     senderAddress: walletAccount.address,
+*   });
+*
+*   if (decision === 'block') return;
+* }
+*
+* await walletClient.sendTransaction(transaction);
+* ```
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns True if the environment has enabled on-transaction sanctions screening for connected wallets, false otherwise.
+* @throws {ValueMustBeDefinedError} If the client has no project settings loaded yet.
+* @see screenTransaction
+* @see isSolanaGasSponsorshipEnabled
+* @notInstrumented
+*/
+const isExternalWalletScreeningEnabled = (client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
+	require_updateAuthFromVerifyResponse.assertDefined(client.projectSettings, "Project settings are not defined");
+	return client.projectSettings.sdk.featureFlags?.enableExternalWalletOnTransactionSanctions ?? false;
+};
+
 //#endregion
 //#region src/modules/wallets/isWalletAccountVerified/isWalletAccountVerified.ts
 /**
@@ -9074,6 +9174,51 @@ const __switchActiveNetwork_wrapped = require_updateAuthFromVerifyResponse.instr
 	}
 });
 
+//#endregion
+//#region src/modules/wallets/screenTransaction/screenTransaction.ts
+/**
+* Screens a connected wallet's transaction for sanctioned addresses before you
+* prompt it to sign, and returns the verdict. Requires an authenticated
+* session.
+*
+* @example
+* ```ts
+* if (isExternalWalletScreeningEnabled()) {
+*   const { decision, blockedAddresses } = await screenTransaction({
+*     chain: 'EVM',
+*     context: { evmTransaction: { to } },
+*     senderAddress: walletAccount.address,
+*   });
+*
+*   if (decision === 'block') {
+*     throw new Error(`Blocked destination: ${blockedAddresses?.join(', ')}`);
+*   }
+* }
+*
+* await walletClient.sendTransaction(transaction);
+* ```
+*
+* @param params.chain - The chain family the transaction is for.
+* @param params.context - The per-chain transaction payload the server extracts addresses from.
+* @param [params.networkId] - The network within the chain family, recorded for audit only.
+* @param [params.senderAddress] - The transaction sender, screened alongside the destinations.
+* @param [params.signal] - Cancels the in-flight request, e.g. `AbortSignal.timeout(2000)`.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The screening verdict, including the addresses that caused a block.
+* @see isExternalWalletScreeningEnabled
+* @see screenSolanaTransactions
+* @notInstrumented
+*/
+const screenTransaction = async ({ chain, context, networkId, senderAddress, signal }, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => require_updateAuthFromVerifyResponse.createApiClient({}, client).screenTransaction({
+	environmentId: require_updateAuthFromVerifyResponse.getCore(client).environmentId,
+	screenTransactionRequest: {
+		chain,
+		chainId: networkId,
+		context,
+		senderAddress
+	}
+}, { signal });
+
 //#endregion
 //#region src/modules/wallets/selectedWalletAccount/setSelectedWalletAccount/setSelectedWalletAccount.ts
 /**
@@ -9481,6 +9626,144 @@ const onWalletProviderEvent = ({ callback, event, walletProviderKey }, client =
 	};
 };
 
+//#endregion
+//#region src/modules/yield/utils/executeYieldTransaction/executeYieldTransaction.ts
+/**
+* Executes a yield vault action's signing payload by signing and sending it
+* on-chain. Delegates to the wallet provider's own `executeYieldTransaction`,
+* which is only implemented by EVM wallet providers for now — other chains
+* fail via {@link assertWalletProviderMethodDefined}.
+*
+* @param params ExecuteYieldTransactionParams - The signing payload, wallet account, and step callback.
+* @param client - The Dynamic client instance.
+* @returns The transaction hash.
+* @see depositToYieldVault
+* @see withdrawFromYieldVault
+* @see claimYieldRewards
+* @notInstrumented
+*/
+const executeYieldTransaction = async ({ onStepChange, signingPayload, walletAccount }, client) => {
+	const walletProvider = require_updateAuthFromVerifyResponse.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	assertWalletProviderMethodDefined(walletProvider, "executeYieldTransaction");
+	await ensureCorrectActiveNetwork({
+		requiredNetworkId: signingPayload.chainId,
+		walletProvider
+	}, client);
+	const { transactionHash } = await walletProvider.executeYieldTransaction({
+		onStepChange,
+		signingPayload,
+		walletAccount
+	});
+	return { transactionHash };
+};
+
+//#endregion
+//#region src/modules/yield/claimYieldRewards/claimYieldRewards.ts
+/**
+* Claims a wallet's accrued rewards in a yield vault, then signs and sends
+* the resulting transaction. The reward distributor's address and the
+* per-user merkle proof live server-side, so callers only need to pass a
+* `vaultId`.
+*
+* Rejects when there is nothing claimable for this vault right now — no
+* reward campaign, or every attributable token is already fully claimed.
+* Read accrued rewards with {@link getYieldRewards} before calling.
+*
+* @example
+* ```ts
+* const { transactionHash } = await claimYieldRewards({ vaultId, walletAccount });
+* ```
+*
+* @param params ClaimYieldRewardsParams - The vault and wallet account to claim for.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The hash of the claim transaction.
+* @see getYieldRewards
+* @see depositToYieldVault
+* @instrumented
+*/
+const claimYieldRewards = async ({ vaultId, walletAccount }, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
+	const core = require_updateAuthFromVerifyResponse.getCore(client);
+	const { signingPayload } = await require_updateAuthFromVerifyResponse.createApiClient({}, client).yieldVaultClaim({
+		environmentId: core.environmentId,
+		vaultId,
+		yieldVaultClaimRequest: { ownerAddress: walletAccount.address }
+	});
+	return executeYieldTransaction({
+		signingPayload,
+		walletAccount
+	}, client);
+};
+const __claimYieldRewards_impl = claimYieldRewards;
+const __claimYieldRewards_wrapped = require_updateAuthFromVerifyResponse.instrumentFunction({
+	fn: __claimYieldRewards_impl,
+	functionName: "claimYieldRewards",
+	getCore: () => {
+		try {
+			return require_updateAuthFromVerifyResponse.getCore(require_updateAuthFromVerifyResponse.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
+//#endregion
+//#region src/modules/yield/depositToYieldVault/depositToYieldVault.ts
+/**
+* Deposits assets into a yield vault, then signs and sends the resulting
+* transaction. The vault's contract address and its asset's decimals live
+* server-side, so callers pass a `vaultId` and a human-readable `amount`
+* rather than encoding a call themselves.
+*
+* When the wallet's allowance for the vault is short of `amount`, an ERC-20
+* approval is signed and sent first — `onStepChange` reports which step is in
+* flight.
+*
+* @example
+* ```ts
+* const { transactionHash } = await depositToYieldVault({
+*   amount: '10.5',
+*   vaultId,
+*   walletAccount,
+* });
+* ```
+*
+* @param params DepositToYieldVaultParams - The vault, wallet account, and amount to deposit.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The hash of the deposit transaction.
+* @see withdrawFromYieldVault
+* @see getYieldPosition
+* @instrumented
+*/
+const depositToYieldVault = async ({ amount, onStepChange, receiverAddress, vaultId, walletAccount }, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
+	const core = require_updateAuthFromVerifyResponse.getCore(client);
+	const { signingPayload } = await require_updateAuthFromVerifyResponse.createApiClient({}, client).yieldVaultDeposit({
+		environmentId: core.environmentId,
+		vaultId,
+		yieldVaultActionRequest: {
+			amount,
+			ownerAddress: walletAccount.address,
+			receiverAddress
+		}
+	});
+	return executeYieldTransaction({
+		onStepChange,
+		signingPayload,
+		walletAccount
+	}, client);
+};
+const __depositToYieldVault_impl = depositToYieldVault;
+const __depositToYieldVault_wrapped = require_updateAuthFromVerifyResponse.instrumentFunction({
+	fn: __depositToYieldVault_impl,
+	functionName: "depositToYieldVault",
+	getCore: () => {
+		try {
+			return require_updateAuthFromVerifyResponse.getCore(require_updateAuthFromVerifyResponse.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/modules/yield/getYieldDetails/getYieldDetails.ts
 /**
@@ -9597,6 +9880,62 @@ const listYieldVaults = async (client = require_updateAuthFromVerifyResponse.get
 	return vaults;
 };
 
+//#endregion
+//#region src/modules/yield/withdrawFromYieldVault/withdrawFromYieldVault.ts
+/**
+* Withdraws assets from a yield vault, then signs and sends the resulting
+* transaction. The vault's contract address and its asset's decimals live
+* server-side, so callers pass a `vaultId` and a human-readable `amount`
+* rather than encoding a call themselves.
+*
+* Unlike {@link depositToYieldVault} there is no approval step — the wallet
+* redeems shares it already holds — so this is always a single transaction.
+*
+* @example
+* ```ts
+* const { transactionHash } = await withdrawFromYieldVault({
+*   amount: '10.5',
+*   vaultId,
+*   walletAccount,
+* });
+* ```
+*
+* @param params WithdrawFromYieldVaultParams - The vault, wallet account, and amount to withdraw.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The hash of the withdraw transaction.
+* @see depositToYieldVault
+* @see getYieldPosition
+* @instrumented
+*/
+const withdrawFromYieldVault = async ({ amount, receiverAddress, vaultId, walletAccount }, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
+	const core = require_updateAuthFromVerifyResponse.getCore(client);
+	const { signingPayload } = await require_updateAuthFromVerifyResponse.createApiClient({}, client).yieldVaultWithdraw({
+		environmentId: core.environmentId,
+		vaultId,
+		yieldVaultActionRequest: {
+			amount,
+			ownerAddress: walletAccount.address,
+			receiverAddress
+		}
+	});
+	return executeYieldTransaction({
+		signingPayload,
+		walletAccount
+	}, client);
+};
+const __withdrawFromYieldVault_impl = withdrawFromYieldVault;
+const __withdrawFromYieldVault_wrapped = require_updateAuthFromVerifyResponse.instrumentFunction({
+	fn: __withdrawFromYieldVault_impl,
+	functionName: "withdrawFromYieldVault",
+	getCore: () => {
+		try {
+			return require_updateAuthFromVerifyResponse.getCore(require_updateAuthFromVerifyResponse.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/utils/appendConnectionUriToDeeplink/appendConnectionUriToDeeplink.ts
 /**
@@ -9764,6 +10103,7 @@ Object.defineProperty(exports, 'ProviderEnum', {
   }
 });
 exports.SandboxMaximumThresholdReachedError = require_updateAuthFromVerifyResponse.SandboxMaximumThresholdReachedError;
+exports.ScreeningNotRequiredError = ScreeningNotRequiredError;
 exports.SimulationFailedError = SimulationFailedError;
 Object.defineProperty(exports, 'TokenScope', {
   enumerable: true,
@@ -9805,6 +10145,7 @@ exports.cancelCheckoutTransaction = __cancelCheckoutTransaction_wrapped;
 exports.cancelFlow = __cancelFlow_wrapped;
 exports.checkStepUpAuth = __checkStepUpAuth_wrapped;
 exports.checkUserScopes = checkUserScopes;
+exports.claimYieldRewards = __claimYieldRewards_wrapped;
 exports.clearDeviceRegistrationRedirectParams = clearDeviceRegistrationRedirectParams;
 exports.clearSocialRedirectParams = clearSocialRedirectParams;
 exports.completeDeviceRegistration = __completeDeviceRegistration_wrapped;
@@ -9824,6 +10165,7 @@ exports.createNewMfaRecoveryCodes = __createNewMfaRecoveryCodes_wrapped;
 exports.deleteMfaDevice = __deleteMfaDevice_wrapped;
 exports.deletePasskey = __deletePasskey_wrapped;
 exports.deleteUser = __deleteUser_wrapped;
+exports.depositToYieldVault = __depositToYieldVault_wrapped;
 exports.detectDeviceRegistrationRedirect = detectDeviceRegistrationRedirect;
 exports.detectOAuthRedirect = detectOAuthRedirect;
 exports.detectSocialRedirectUrl = detectSocialRedirectUrl;
@@ -9889,6 +10231,7 @@ exports.isAnyWalletAccountConnected = isAnyWalletAccountConnected;
 exports.isCaptchaRequired = require_getNetworkProviderFromNetworkId.isCaptchaRequired;
 exports.isDeeplinkWalletProvider = isDeeplinkWalletProvider;
 exports.isDeviceRegistrationRequired = require_isUserOnboardingComplete.isDeviceRegistrationRequired;
+exports.isExternalWalletScreeningEnabled = isExternalWalletScreeningEnabled;
 exports.isHardwareWalletAccount = isHardwareWalletAccount;
 exports.isInsufficientGoogleDriveScopesError = isInsufficientGoogleDriveScopesError;
 exports.isMfaRequiredForAction = require_isMfaRequiredForAction.isMfaRequiredForAction;
@@ -9921,6 +10264,7 @@ exports.requestExternalAuthElevatedToken = __requestExternalAuthElevatedToken_wr
 exports.requiresConversion = requiresConversion;
 exports.revokeAllRegisteredDevices = __revokeAllRegisteredDevices_wrapped;
 exports.revokeRegisteredDevice = __revokeRegisteredDevice_wrapped;
+exports.screenTransaction = screenTransaction;
 exports.selectPrimaryWalletAccount = __selectPrimaryWalletAccount_wrapped;
 exports.sendEmailOTP = __sendEmailOTP_wrapped;
 exports.sendSmsOTP = __sendSmsOTP_wrapped;
@@ -9945,4 +10289,5 @@ exports.updateUser = __updateUser_wrapped;
 exports.verifyOTP = __verifyOTP_wrapped;
 exports.verifyWalletAccount = __verifyWalletAccount_wrapped;
 exports.waitForClientInitialized = waitForClientInitialized;
+exports.withdrawFromYieldVault = __withdrawFromYieldVault_wrapped;
 //# sourceMappingURL=index.cjs.map