@dynamic-labs-sdk/tempo 0.0.0-stage → 1.40.0

package/dist/waas.cjs

@@ -0,0 +1,758 @@
+const require_tempoChainIds = require('./tempoChainIds-wtNAU12H.cjs');
+let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
+let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
+let viem = require("viem");
+let _dynamic_labs_sdk_client_waas_core = require("@dynamic-labs-sdk/client/waas/core");
+let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
+let viem_accounts = require("viem/accounts");
+
+//#region src/waas/sendTempoTransaction/sendTempoTransaction.ts
+/**
+* Sends a Tempo transaction from a Tempo embedded wallet, including the
+* Tempo-only fields: batched calls, a fee token, a nonce key and a validity
+* window. Use it when a plain viem `sendTransaction` cannot express the
+* transaction.
+*
+* @param params.walletAccount - The Tempo embedded wallet account that sends.
+* @param params.calls - The calls the transaction executes atomically.
+* @param [params.feeToken] - TIP-20 token address used to pay the fee.
+* @param [params.gas] - Gas limit. Defaults to a buffered estimate.
+* @param [params.nonceKey] - Nonce key selecting a parallel nonce lane.
+* @param [params.validAfter] - Unix timestamp after which the transaction is valid.
+* @param [params.validBefore] - Unix timestamp after which the transaction expires.
+* @param [client] - The Dynamic client instance. Only required when using multiple clients.
+* @returns The transaction hash.
+* @throws {InvalidParamError} If the wallet account is not a Tempo wallet account.
+* @example
+* ```ts
+* const { transactionHash } = await sendTempoTransaction({
+*   calls: [
+*     { data: transferData, to: tokenAddress },
+*     { data: approveData, to: tokenAddress },
+*   ],
+*   feeToken: tokenAddress,
+*   walletAccount,
+* });
+* ```
+* @see sendTip20Transaction
+* @see getTempoPublicClient
+* @notInstrumented
+*/
+const sendTempoTransaction = async ({ walletAccount, ...transaction }, client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	const walletProvider = (0, _dynamic_labs_sdk_client_core.getWalletProviderFromWalletAccount)({ walletAccount }, client);
+	if (!require_tempoChainIds.isTempoWalletProvider(walletProvider)) throw new _dynamic_labs_sdk_client.InvalidParamError("Wallet account is not a Tempo wallet account");
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(walletProvider.createViemWalletClient, "Tempo wallet provider cannot create a wallet client");
+	const walletClient = await walletProvider.createViemWalletClient({ walletAccount });
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(walletClient.account.signTransaction, "Tempo account cannot sign transactions");
+	const serializedTransaction = await walletClient.account.signTransaction(transaction);
+	return { transactionHash: await walletClient.sendRawTransaction({ serializedTransaction }) };
+};
+
+//#endregion
+//#region src/constants.ts
+/**
+* Chain identifier shared by every Tempo wallet provider, network provider and
+* signing request.
+*/
+const TEMPO_CHAIN = "TEMPO";
+
+//#endregion
+//#region src/errors/InvalidTempoNetworkError/InvalidTempoNetworkError.ts
+/**
+* Thrown when a Tempo wallet provider is asked to activate a network that is
+* not a Tempo network.
+*
+* @example
+* ```ts
+* throw new InvalidTempoNetworkError({ networkId: '1' });
+* ```
+*
+* @see isTempoChainId
+* @see addWaasTempoExtension
+*/
+var InvalidTempoNetworkError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor({ networkId }) {
+		super({
+			cause: null,
+			code: "invalid_tempo_network_error",
+			docsUrl: null,
+			name: "InvalidTempoNetworkError",
+			shortMessage: `Network ${networkId} is not a Tempo network`
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/TempoBusinessAccountTransactionNotSupportedError/TempoBusinessAccountTransactionNotSupportedError.ts
+/**
+* Thrown when a business-account Tempo wallet is asked to sign a transaction.
+* Business-account transactions need a signing-quorum intent, which the
+* embedded wallet signer does not support for Tempo transactions yet.
+*
+* @example
+* ```ts
+* throw new TempoBusinessAccountTransactionNotSupportedError();
+* ```
+*
+* @see addWaasTempoExtension
+*/
+var TempoBusinessAccountTransactionNotSupportedError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "tempo_business_account_transaction_not_supported_error",
+			docsUrl: null,
+			name: "TempoBusinessAccountTransactionNotSupportedError",
+			shortMessage: "Signing Tempo transactions with a business account wallet is not supported"
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/tempoConfirmTransaction/tempoConfirmTransaction.ts
+/**
+* Waits until a transaction sent from a Tempo wallet account is included in a
+* block.
+*
+* @param params.transactionHash - The hash of the transaction to wait for.
+* @param params.walletAccount - The Tempo wallet account that sent it.
+* @param client - The Dynamic client instance.
+* @returns Nothing. Resolves once the transaction receipt is available.
+* @throws {InvalidParamError} If the wallet account is not a Tempo wallet account.
+* @example
+* ```ts
+* await tempoConfirmTransaction({ transactionHash, walletAccount }, client);
+* ```
+* @see tempoTransferAmount
+* @see getTempoPublicClient
+* @notInstrumented
+*/
+const tempoConfirmTransaction = async ({ transactionHash, walletAccount }, client) => {
+	if (!require_tempoChainIds.isTempoWalletAccount(walletAccount)) throw new _dynamic_labs_sdk_client.InvalidParamError("Wallet account is not a Tempo wallet account");
+	await (await require_tempoChainIds.getTempoPublicClient({ walletAccount }, client)).waitForTransactionReceipt({ hash: transactionHash });
+};
+
+//#endregion
+//#region src/utils/tempoTransferAmount/tempoTransferAmount.ts
+/**
+* Transfers a TIP-20 token from a Tempo wallet account. Tempo has no native
+* token, so the token is required.
+*
+* @param params.amount - Human-readable amount, e.g. '1.5'.
+* @param params.recipient - Recipient address.
+* @param params.token - The TIP-20 token to transfer.
+* @param params.walletAccount - The Tempo wallet account that sends.
+* @param params.createViemWalletClient - Creates the viem wallet client that signs.
+* @returns The transaction hash.
+* @throws {InvalidParamError} If the wallet account is not a Tempo wallet account.
+* @throws {TempoNativeTokenError} If no token is provided.
+* @example
+* ```ts
+* const { transactionHash } = await tempoTransferAmount({
+*   amount: '1.5',
+*   createViemWalletClient,
+*   recipient: '0xRecipient',
+*   token: { address: '0xTip20Token', decimals: 6 },
+*   walletAccount,
+* });
+* ```
+* @see sendTip20Transaction
+* @see tempoConfirmTransaction
+* @notInstrumented
+*/
+const tempoTransferAmount = async ({ amount, createViemWalletClient, recipient, token, walletAccount }) => {
+	if (!require_tempoChainIds.isTempoWalletAccount(walletAccount)) throw new _dynamic_labs_sdk_client.InvalidParamError("Wallet account is not a Tempo wallet account");
+	if (!token?.address) throw new require_tempoChainIds.TempoNativeTokenError();
+	const walletClient = await createViemWalletClient({ walletAccount });
+	return { transactionHash: await require_tempoChainIds.sendTip20Transaction({
+		amount,
+		decimals: token.decimals,
+		to: recipient,
+		tokenAddress: token.address,
+		walletClient
+	}) };
+};
+
+//#endregion
+//#region src/errors/TempoRawMessageNotUtf8Error/TempoRawMessageNotUtf8Error.ts
+/**
+* Thrown when a raw message passed to a Tempo embedded wallet is not valid
+* UTF-8 text. The embedded wallet signs text messages, so bytes that cannot be
+* decoded and re-encoded unchanged would be signed as different bytes.
+*
+* @example
+* ```ts
+* throw new TempoRawMessageNotUtf8Error();
+* ```
+*
+* @see createWalletProviderForWaasTempo
+*/
+var TempoRawMessageNotUtf8Error = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "tempo_raw_message_not_utf8_error",
+			docsUrl: null,
+			name: "TempoRawMessageNotUtf8Error",
+			shortMessage: "Raw messages must be valid UTF-8 text to be signed by a Tempo embedded wallet"
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/TempoTransactionValidationError/TempoTransactionValidationError.ts
+/**
+* Thrown when a Tempo transaction fails validation before signing, for
+* example because of a malformed address or non-hex call data.
+*
+* @example
+* ```ts
+* throw new TempoTransactionValidationError({ reason: 'malformed call data' });
+* ```
+*
+* @see createWalletProviderForWaasTempo
+* @see addWaasTempoExtension
+*/
+var TempoTransactionValidationError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor({ reason }) {
+		super({
+			cause: null,
+			code: "tempo_transaction_validation_error",
+			docsUrl: null,
+			name: "TempoTransactionValidationError",
+			shortMessage: `Invalid Tempo transaction: ${reason}`
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/TempoTypedDataNotSupportedError/TempoTypedDataNotSupportedError.ts
+/**
+* Thrown when typed data is signed with a Tempo embedded wallet, which does
+* not support it yet.
+*
+* @example
+* ```ts
+* throw new TempoTypedDataNotSupportedError();
+* ```
+*
+* @see createWalletProviderForWaasTempo
+* @see addWaasTempoExtension
+*/
+var TempoTypedDataNotSupportedError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "tempo_typed_data_not_supported",
+			docsUrl: null,
+			name: "TempoTypedDataNotSupportedError",
+			shortMessage: "Signing typed data is not supported for Tempo embedded wallets yet"
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/utils/assertValidTempoTransactionCalls/assertValidTempoTransactionCalls.ts
+/**
+* Rejects malformed calls before they reach the signer, which would otherwise
+* fail with an opaque parsing error.
+*
+* @param params.calls - The Tempo calls to validate.
+* @returns Nothing. Throws on malformed input.
+* @throws {TempoTransactionValidationError} If a call is malformed or the batch is empty.
+* @example
+* ```ts
+* assertValidTempoTransactionCalls({ calls: [{ to, data, value }] });
+* ```
+* @notInstrumented
+*/
+const assertValidTempoTransactionCalls = ({ calls }) => {
+	if (calls.length === 0) throw new TempoTransactionValidationError({ reason: "at least one call is required" });
+	for (const call of calls) {
+		if (call.to !== void 0 && !(0, viem.isAddress)(call.to)) throw new TempoTransactionValidationError({ reason: "malformed call address" });
+		if (call.data !== void 0 && !(0, viem.isHex)(call.data)) throw new TempoTransactionValidationError({ reason: "malformed call data" });
+		if (call.value !== void 0 && typeof call.value !== "bigint") throw new TempoTransactionValidationError({ reason: "malformed call value" });
+	}
+};
+
+//#endregion
+//#region src/waas/utils/assertValidTempoTransactionRequest/assertValidTempoTransactionRequest.ts
+/**
+* Rejects malformed Tempo transaction fields before they reach the signer,
+* which would otherwise fail with an opaque parsing error.
+*
+* @param params.transaction - The Tempo transaction request to validate.
+* @param params.chainId - The chain id of the active Tempo network.
+* @returns Nothing. Throws on malformed input.
+* @throws {TempoTransactionValidationError} If a field is malformed or inconsistent.
+* @example
+* ```ts
+* assertValidTempoTransactionRequest({ transaction, chainId: 4217 });
+* ```
+* @notInstrumented
+*/
+const assertValidTempoTransactionRequest = ({ transaction, chainId }) => {
+	if (transaction.feeToken !== void 0 && !(0, viem.isAddress)(transaction.feeToken)) throw new TempoTransactionValidationError({ reason: "malformed feeToken address" });
+	if (transaction.calls !== void 0 && (transaction.to !== void 0 || transaction.data !== void 0 || transaction.value !== void 0)) throw new TempoTransactionValidationError({ reason: "calls cannot be combined with top-level to, data or value" });
+	if (transaction.chainId !== void 0 && transaction.chainId !== chainId) throw new TempoTransactionValidationError({ reason: "chainId does not match the active Tempo network" });
+	if (transaction.nonceKey !== void 0 && (typeof transaction.nonceKey !== "bigint" || transaction.nonceKey < 0n)) throw new TempoTransactionValidationError({ reason: "nonceKey must be a non-negative bigint" });
+	for (const field of ["validAfter", "validBefore"]) {
+		const value = transaction[field];
+		if (value !== void 0 && (!Number.isInteger(value) || value < 0)) throw new TempoTransactionValidationError({ reason: `${field} must be a non-negative integer timestamp` });
+	}
+	if (transaction.validAfter !== void 0 && transaction.validBefore !== void 0 && transaction.validAfter >= transaction.validBefore) throw new TempoTransactionValidationError({ reason: "validAfter must be before validBefore" });
+};
+
+//#endregion
+//#region src/waas/utils/isBusinessAccountWalletAccount/isBusinessAccountWalletAccount.ts
+/**
+* Type guard — returns true if the wallet account belongs to a business
+* account, meaning its signatures need a signing-quorum approval.
+*
+* @param walletAccount - The wallet account to check.
+* @returns Whether the wallet account has a business account id.
+* @example
+* ```ts
+* if (isBusinessAccountWalletAccount(walletAccount)) {
+*   console.log(walletAccount.businessAccountId);
+* }
+* ```
+* @see signMessage
+* @see signRawMessage
+* @notInstrumented
+*/
+const isBusinessAccountWalletAccount = (walletAccount) => "businessAccountId" in walletAccount && typeof walletAccount.businessAccountId === "string" && walletAccount.businessAccountId !== "";
+
+//#endregion
+//#region src/waas/utils/serializeTempoTransactionForWaas/serializeTempoTransactionForWaas.ts
+/**
+* Serializes a Tempo transaction to the JSON an embedded wallet signs.
+* BigInt values are written as decimal strings because JSON has no BigInt type.
+*
+* @param params - The Tempo transaction fields to serialize.
+* @returns The JSON-encoded transaction.
+* @example
+* ```ts
+* const transaction = serializeTempoTransactionForWaas({
+*   calls: [{ to: '0xabc', value: 1n }],
+*   chainId: 4217,
+*   gas: 300_000n,
+*   maxFeePerGas: 1_000n,
+*   maxPriorityFeePerGas: 100n,
+*   nonce: 0,
+* });
+* ```
+* @see addWaasTempoExtension
+* @see createWalletProviderForWaasTempo
+* @notInstrumented
+*/
+const serializeTempoTransactionForWaas = ({ calls, chainId, feeToken, gas, maxFeePerGas, maxPriorityFeePerGas, nonce, nonceKey, validAfter, validBefore }) => JSON.stringify({
+	calls: calls.map(({ data, to, value }) => ({
+		data,
+		to,
+		value
+	})),
+	chainId,
+	feeToken,
+	gas,
+	maxFeePerGas,
+	maxPriorityFeePerGas,
+	nonce,
+	nonceKey,
+	validAfter,
+	validBefore
+}, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+
+//#endregion
+//#region src/waas/utils/signMessage/signMessage.ts
+/**
+* Signs a message with a Tempo embedded wallet account.
+*
+* For a business-account wallet, this first prepares and signs the quorum
+* intent for the message. Personal wallets pass `approvalQuorum` through
+* unchanged.
+*
+* @param params.approvalQuorum - A signed intent from an earlier `SigningConsentRequiredError`, when retrying.
+* @param params.message - The message to sign.
+* @param params.waasProvider - The WaaS provider that prepares the intent and signs.
+* @param params.walletAccount - The wallet account that signs the message.
+* @param client - The Dynamic client holding the current session key.
+* @returns The signature.
+* @example
+* ```ts
+* const { signature } = await signMessage(
+*   { message, waasProvider, walletAccount },
+*   client
+* );
+* ```
+* @see {@link prepareSigningQuorumApproval} for the quorum intent step.
+* @see {@link isSigningConsentRequiredError} for handling an unmet signing quorum.
+* @notInstrumented
+*/
+const signMessage = async ({ approvalQuorum, message, waasProvider, walletAccount }, client) => {
+	const preparedApprovalQuorum = await (0, _dynamic_labs_sdk_client_waas_core.prepareSigningQuorumApproval)({
+		approvalQuorum,
+		chainName: TEMPO_CHAIN,
+		operation: {
+			kind: "message",
+			message
+		},
+		waasClient: await waasProvider.getWaasClient(),
+		walletAccount
+	}, client);
+	return waasProvider.signMessage({
+		approvalQuorum: preparedApprovalQuorum,
+		message,
+		walletAccount
+	});
+};
+
+//#endregion
+//#region src/waas/utils/createViemWalletClientForWaasTempo/createViemWalletClientForWaasTempo.ts
+const TEMPO_GAS_BUFFER_NUMERATOR = 130n;
+const TEMPO_GAS_BUFFER_DENOMINATOR = 100n;
+const TEMPO_MIN_GAS = 300000n;
+/**
+* Address of the Tempo nonce manager, which keeps one nonce counter per
+* account and nonce key.
+*/
+const TEMPO_NONCE_MANAGER_ADDRESS = "0x4e4F4E4345000000000000000000000000000000";
+const TEMPO_NONCE_MANAGER_ABI = [{
+	inputs: [{
+		name: "account",
+		type: "address"
+	}, {
+		name: "nonceKey",
+		type: "uint256"
+	}],
+	name: "getNonce",
+	outputs: [{
+		name: "nonce",
+		type: "uint64"
+	}],
+	stateMutability: "view",
+	type: "function"
+}];
+/**
+* Creates a viem wallet client for a Tempo embedded wallet account.
+*
+* Transactions are signed as Tempo transactions: batched `calls`, `feeToken`,
+* `nonceKey` and `validAfter` / `validBefore` pass through to the signer. Gas
+* is the larger of the caller's value and a 30% buffered estimate with a 300k
+* floor, fees are at least the network gas price, and the nonce is the next
+* one on the requested nonce lane.
+*
+* @param params.waasProvider - The embedded wallet provider that signs.
+* @param params.walletAccount - The Tempo embedded wallet account that signs.
+* @param [params.httpTransportConfig] - Optional viem HTTP transport config.
+* @param [params.viemWalletClientConfig] - Optional extra viem client config.
+* @param client - The Dynamic client instance.
+* @returns A viem wallet client bound to the Tempo account.
+* @throws If no active network data exists for the wallet account.
+* @example
+* ```ts
+* const walletClient = await createViemWalletClientForWaasTempo(
+*   { waasProvider, walletAccount },
+*   client
+* );
+*
+* const hash = await walletClient.sendTransaction({ to, data });
+* ```
+* @see serializeTempoTransactionForWaas
+* @see createWalletProviderForWaasTempo
+* @notInstrumented
+*/
+const createViemWalletClientForWaasTempo = async ({ waasProvider, walletAccount, httpTransportConfig, viemWalletClientConfig }, dynamicClient) => {
+	const { networkData: activeNetworkData } = await (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, dynamicClient);
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(activeNetworkData, "No active network data found for the provided wallet account");
+	const chain = require_tempoChainIds.mapNetworkDataToViemChain(activeNetworkData);
+	const transport = (0, viem.http)(activeNetworkData.rpcUrls.http[0], httpTransportConfig);
+	const publicClient = (0, viem.createPublicClient)({
+		chain,
+		transport
+	});
+	const estimateTempoGas = async ({ calls, hasExplicitGas }) => {
+		const buffered = (await Promise.all(calls.map(async (call) => {
+			try {
+				return await publicClient.estimateGas({
+					account: walletAccount.address,
+					data: call.data,
+					to: call.to,
+					value: call.value
+				});
+			} catch (error) {
+				if (calls.length === 1 && !hasExplicitGas) throw error;
+				return TEMPO_MIN_GAS;
+			}
+		}))).reduce((total, value) => total + value, 0n) * TEMPO_GAS_BUFFER_NUMERATOR / TEMPO_GAS_BUFFER_DENOMINATOR;
+		return buffered > TEMPO_MIN_GAS ? buffered : TEMPO_MIN_GAS;
+	};
+	const getTempoNonce = async ({ nonceKey }) => {
+		if (nonceKey === void 0 || nonceKey === 0n) return publicClient.getTransactionCount({ address: walletAccount.address });
+		return Number(await publicClient.readContract({
+			abi: TEMPO_NONCE_MANAGER_ABI,
+			address: TEMPO_NONCE_MANAGER_ADDRESS,
+			args: [walletAccount.address, nonceKey],
+			functionName: "getNonce"
+		}));
+	};
+	return (0, viem.createWalletClient)({
+		account: (0, viem_accounts.toAccount)({
+			address: walletAccount.address,
+			signMessage: async ({ message }) => {
+				let signableMessage;
+				if (typeof message === "string") signableMessage = message;
+				else {
+					const raw = (0, viem.isHex)(message.raw) ? message.raw : (0, viem.bytesToHex)(message.raw);
+					signableMessage = (0, viem.hexToString)(raw);
+					if ((0, viem.stringToHex)(signableMessage) !== raw.toLowerCase()) throw new TempoRawMessageNotUtf8Error();
+				}
+				const { signature } = await signMessage({
+					message: signableMessage,
+					waasProvider,
+					walletAccount
+				}, dynamicClient);
+				return signature;
+			},
+			signTransaction: async (transaction) => {
+				if (isBusinessAccountWalletAccount(walletAccount)) throw new TempoBusinessAccountTransactionNotSupportedError();
+				assertValidTempoTransactionRequest({
+					chainId: chain.id,
+					transaction
+				});
+				const calls = transaction.calls ?? [{
+					data: transaction.data ?? "0x",
+					to: transaction.to ?? void 0,
+					value: transaction.value ?? 0n
+				}];
+				assertValidTempoTransactionCalls({ calls });
+				const estimatedGas = await estimateTempoGas({
+					calls,
+					hasExplicitGas: transaction.gas !== void 0
+				});
+				const gas = transaction.gas !== void 0 && transaction.gas > estimatedGas ? transaction.gas : estimatedGas;
+				const nonce = transaction.nonceKey !== void 0 && transaction.nonceKey !== 0n ? await getTempoNonce({ nonceKey: transaction.nonceKey }) : transaction.nonce ?? await getTempoNonce({ nonceKey: transaction.nonceKey });
+				const gasPrice = await publicClient.getGasPrice();
+				const priorityGasPrice = gasPrice / 10n;
+				const requestedGasPrice = "gasPrice" in transaction ? transaction.gasPrice : void 0;
+				const requestedMaxFeePerGas = transaction.maxFeePerGas ?? requestedGasPrice;
+				const requestedMaxPriorityFeePerGas = transaction.maxPriorityFeePerGas ?? requestedGasPrice;
+				const maxFeePerGas = requestedMaxFeePerGas !== void 0 && requestedMaxFeePerGas > gasPrice ? requestedMaxFeePerGas : gasPrice;
+				const maxPriorityFeePerGas = requestedMaxPriorityFeePerGas !== void 0 && requestedMaxPriorityFeePerGas > priorityGasPrice ? requestedMaxPriorityFeePerGas : priorityGasPrice;
+				if (maxPriorityFeePerGas > maxFeePerGas) throw new TempoTransactionValidationError({ reason: "maxPriorityFeePerGas must not exceed maxFeePerGas" });
+				const serializedTransaction = serializeTempoTransactionForWaas({
+					calls,
+					chainId: chain.id,
+					feeToken: transaction.feeToken,
+					gas,
+					maxFeePerGas,
+					maxPriorityFeePerGas,
+					nonce,
+					nonceKey: transaction.nonceKey,
+					validAfter: transaction.validAfter,
+					validBefore: transaction.validBefore
+				});
+				const { signature } = await waasProvider.signSerializedTransaction({
+					serializedTransaction,
+					walletAccount
+				});
+				return signature;
+			},
+			signTypedData: () => {
+				throw new TempoTypedDataNotSupportedError();
+			}
+		}),
+		chain,
+		transport,
+		...viemWalletClientConfig
+	});
+};
+
+//#endregion
+//#region src/waas/utils/signRawMessage/signRawMessage.ts
+/**
+* Signs a raw message with a Tempo embedded wallet account.
+*
+* For a business-account wallet, `rawSign` is required: the quorum intent
+* commits to its preimage, so the intent can be checked before signing.
+*
+* @param params.approvalQuorum - A signed intent from an earlier `SigningConsentRequiredError`, when retrying.
+* @param params.message - The raw message to sign.
+* @param [params.password] - The wallet password, if the wallet is password protected.
+* @param [params.rawSign] - The hex preimage and hash metadata that the intent commits to.
+* @param params.waasProvider - The WaaS provider that prepares the intent and signs.
+* @param params.walletAccount - The wallet account that signs the message.
+* @param client - The Dynamic client holding the current session key.
+* @returns The signature.
+* @throws {InvalidParamError} If a business-account wallet has no `rawSign`.
+* @example
+* ```ts
+* const { signature } = await signRawMessage(
+*   { message, rawSign, waasProvider, walletAccount },
+*   client
+* );
+* ```
+* @see {@link prepareSigningQuorumApproval} for the quorum intent step.
+* @see {@link isSigningConsentRequiredError} for handling an unmet signing quorum.
+* @notInstrumented
+*/
+const signRawMessage = async ({ approvalQuorum, message, password, rawSign, waasProvider, walletAccount }, client) => {
+	if (isBusinessAccountWalletAccount(walletAccount) && !rawSign) throw new _dynamic_labs_sdk_client.InvalidParamError("Raw signing for a business-account wallet requires a verifiable preimage");
+	const preparedApprovalQuorum = rawSign ? await (0, _dynamic_labs_sdk_client_waas_core.prepareSigningQuorumApproval)({
+		approvalQuorum,
+		chainName: TEMPO_CHAIN,
+		operation: {
+			kind: "raw",
+			message,
+			rawSign
+		},
+		waasClient: await waasProvider.getWaasClient(),
+		walletAccount
+	}, client) : approvalQuorum;
+	return waasProvider.signRawMessage({
+		approvalQuorum: preparedApprovalQuorum,
+		message,
+		password,
+		rawSign,
+		walletAccount
+	});
+};
+
+//#endregion
+//#region src/waas/utils/createWalletProviderForWaasTempo/createWalletProviderForWaasTempo.ts
+/**
+* Creates the embedded wallet provider for the Tempo chain.
+*
+* @param params.dynamicClient - The Dynamic client the provider is bound to.
+* @returns A wallet provider that signs with Tempo embedded wallets.
+* @throws {InvalidTempoNetworkError} When the returned provider is asked to switch to a network that is not a Tempo network.
+* @throws {TempoBusinessAccountTransactionNotSupportedError} When the returned provider is asked to sign a transaction with a business-account wallet.
+* @example
+* ```ts
+* const walletProvider = createWalletProviderForWaasTempo({ dynamicClient });
+* ```
+* @see addWaasTempoExtension
+* @see WaasTempoWalletProvider
+* @notInstrumented
+*/
+const createWalletProviderForWaasTempo = ({ dynamicClient }) => {
+	const chain = TEMPO_CHAIN;
+	const walletProviderType = _dynamic_labs_sdk_api_core.WalletProviderEnum.EmbeddedWallet;
+	const key = (0, _dynamic_labs_sdk_client_core.formatWalletProviderKey)({
+		chain,
+		displayName: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName,
+		walletProviderType
+	});
+	const waasProvider = (0, _dynamic_labs_sdk_client_waas_core.createWaasProvider)({
+		chain,
+		sdkClient: dynamicClient
+	});
+	const createViemWalletClient = async ({ walletAccount, httpTransportConfig, viemWalletClientConfig }) => createViemWalletClientForWaasTempo({
+		httpTransportConfig,
+		viemWalletClientConfig,
+		waasProvider,
+		walletAccount
+	}, dynamicClient);
+	const getActiveNetworkId = () => (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+		client: dynamicClient,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = () => Promise.resolve({ addresses: (0, _dynamic_labs_sdk_client_waas_core.getAllUserWaasAddressesForChain)({ chain }, dynamicClient) });
+	const signMessage$1 = async ({ approvalQuorum, message, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		return signMessage({
+			approvalQuorum,
+			message,
+			waasProvider,
+			walletAccount
+		}, dynamicClient);
+	};
+	const signRawMessage$1 = async (args) => signRawMessage({
+		...args,
+		waasProvider
+	}, dynamicClient);
+	const signSerializedTransaction = async (args) => {
+		if (isBusinessAccountWalletAccount(args.walletAccount)) throw new TempoBusinessAccountTransactionNotSupportedError();
+		return await waasProvider.signSerializedTransaction(args);
+	};
+	const switchActiveNetwork = async ({ networkId }) => {
+		if (!require_tempoChainIds.isTempoChainId(networkId)) throw new InvalidTempoNetworkError({ networkId });
+		await (0, _dynamic_labs_sdk_client_core.switchActiveNetworkInLastKnownRegistry)({
+			client: dynamicClient,
+			networkId,
+			walletProviderKey: key
+		});
+	};
+	const destroy = (args) => waasProvider.destroy(args);
+	return {
+		...waasProvider,
+		chain,
+		confirmTransaction: (args) => tempoConfirmTransaction(args, dynamicClient),
+		createViemWalletClient,
+		destroy,
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: (0, _dynamic_labs_sdk_client_core.formatWalletProviderGroupKey)(_dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName),
+		key,
+		metadata: {
+			displayName: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName,
+			icon: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.icon
+		},
+		signMessage: signMessage$1,
+		signRawMessage: signRawMessage$1,
+		signSerializedTransaction,
+		supportsFeeTokenSelection: true,
+		switchActiveNetwork,
+		transferAmount: (args) => tempoTransferAmount({
+			...args,
+			createViemWalletClient
+		}),
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/waas/addWaasTempoExtension/addWaasTempoExtension.ts
+/** Registry key for the Tempo embedded wallet extension registered by addWaasTempoExtension. */
+const WAAS_TEMPO_EXTENSION_KEY = "waasTempo";
+/**
+* Registers Tempo embedded wallet support with the Dynamic client: the Tempo
+* network provider and the embedded wallet provider for Tempo.
+* Calling it more than once is safe: later calls do nothing.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple clients.
+* @returns Nothing. The extension is registered on the client.
+* @example
+* ```ts
+* import { addWaasTempoExtension } from '@dynamic-labs-sdk/tempo/waas';
+*
+* addWaasTempoExtension(dynamicClient);
+* ```
+* @see addTempoExtension
+* @see isTempoWalletAccount
+* @notInstrumented
+*/
+const addWaasTempoExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: WAAS_TEMPO_EXTENSION_KEY }, client)) return;
+	(0, _dynamic_labs_sdk_client_core.registerExtension)({ extensionKey: WAAS_TEMPO_EXTENSION_KEY }, client);
+	require_tempoChainIds.registerTempoNetworkProviderBuilder(client);
+	const walletProviderRegistry = (0, _dynamic_labs_sdk_client_core.getWalletProviderRegistry)(client);
+	const walletProvider = createWalletProviderForWaasTempo({ dynamicClient: client });
+	walletProviderRegistry.register({
+		priority: _dynamic_labs_sdk_client_core.WalletProviderPriority.WALLET_SDK,
+		walletProvider
+	});
+};
+
+//#endregion
+//#region src/exports/waas.ts
+(0, _dynamic_labs_sdk_assert_package_version.assertPackageVersion)(require_tempoChainIds.name, require_tempoChainIds.version);
+
+//#endregion
+exports.InvalidTempoNetworkError = InvalidTempoNetworkError;
+exports.TempoTransactionValidationError = TempoTransactionValidationError;
+exports.TempoTypedDataNotSupportedError = TempoTypedDataNotSupportedError;
+exports.addWaasTempoExtension = addWaasTempoExtension;
+exports.sendTempoTransaction = sendTempoTransaction;
+//# sourceMappingURL=waas.cjs.map