@turnkey/core 2.2.0 → 2.4.0

package/dist/__clients__/core.mjs

@@ -312,13 +312,14 @@ class TurnkeyClient {
          * @param params.expirationSeconds - session expiration time in seconds (defaults to the configured default).
          * @param params.createSubOrgParams - parameters for creating a sub-organization (e.g., authenticators, user metadata).
          * @param params.sessionKey - session key to use for storing the session (defaults to the default session key).
+         * @param params.captchaToken - optional captcha token for bot prevention (must be enabled in the auth proxy config to take effect).
          * @returns A promise that resolves to a {@link PasskeyAuthResult}, which includes:
          *          - `sessionToken`: the signed JWT session token.
          *          - `credentialId`: the credential ID associated with the passkey created.
          * @throws {TurnkeyError} If there is an error during passkey creation, sub-organization creation, or session storage.
          */
         this.signUpWithPasskey = async (params) => {
-            const { passkeyDisplayName, challenge, expirationSeconds = DEFAULT_SESSION_EXPIRATION_IN_SECONDS, createSubOrgParams, sessionKey = SessionKey.DefaultSessionkey, } = params || {};
+            const { passkeyDisplayName, challenge, expirationSeconds = DEFAULT_SESSION_EXPIRATION_IN_SECONDS, createSubOrgParams, sessionKey = SessionKey.DefaultSessionkey, captchaToken, } = params || {};
             const generatedPublicKey = await this.createApiKeyPair();
             return withTurnkeyErrorHandling(async () => {
                 if (!this.passkeyStamper) {
@@ -355,7 +356,7 @@ class TurnkeyClient {
                         ],
                     },
                 });
-                const res = await this.httpClient.proxySignupV2(signUpBody);
+                const res = await this.httpClient.proxySignupV2(signUpBody, captchaToken);
                 if (!res) {
                     throw new TurnkeyError(`Sign up failed`, TurnkeyErrorCodes.PASSKEY_SIGNUP_AUTH_ERROR);
                 }
@@ -703,6 +704,7 @@ class TurnkeyClient {
          * @param params.sessionKey - session key to use for storing the session (defaults to the default session key).
          * @param params.expirationSeconds - session expiration time in seconds (defaults to the configured default).
          * @param params.organizationId - organization ID to target (defaults to the session's organization ID or the parent organization ID).
+         * @param params.captchaToken - optional captcha token for bot prevention during OTP initialization (must be enabled in the auth proxy config to take effect).
          * @returns A promise that resolves to an object containing:
          *          - `sessionToken`: the signed JWT session token.
          *          - `address`: the authenticated wallet address.
@@ -710,7 +712,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during wallet authentication, sub-organization creation, or session storage.
          */
         this.loginOrSignupWithWallet = async (params) => {
-            const { walletProvider, createSubOrgParams, sessionKey = SessionKey.DefaultSessionkey, } = params;
+            const { walletProvider, createSubOrgParams, sessionKey = SessionKey.DefaultSessionkey, captchaToken, } = params;
             return withTurnkeyErrorHandling(async () => {
                 const { signedRequest, publicKey } = await this.buildWalletLoginRequest(params);
                 // here we check if the subOrg exists and create one
@@ -738,7 +740,7 @@ class TurnkeyClient {
                             ],
                         },
                     });
-                    signupRes = await this.httpClient.proxySignupV2(signUpBody);
+                    signupRes = await this.httpClient.proxySignupV2(signUpBody, captchaToken);
                     if (!signupRes) {
                         throw new TurnkeyError(`Sign up failed`, TurnkeyErrorCodes.WALLET_SIGNUP_AUTH_ERROR);
                     }
@@ -776,6 +778,7 @@ class TurnkeyClient {
          * @param params.otpType - type of OTP to initialize (OtpType.Email or OtpType.Sms).
          * @param params.contact - contact information for the user (e.g., email address or phone number).
          * @param params.organizationId - optional organization ID to target (defaults to the session's organization ID or the parent organization ID).
+         * @param params.captchaToken - optional captcha token for bot prevention during OTP initialization (must be enabled in the auth proxy config to take effect).
          * @returns A promise that resolves to an {@link InitOtpResult}, which includes:
          *          - `otpId`: the ID of the initiated OTP.
          *          - `otpEncryptionTargetBundle`: the signed encryption target bundle for encrypting the OTP code.
@@ -783,7 +786,11 @@ class TurnkeyClient {
          */
         this.initOtp = async (params) => {
             return withTurnkeyErrorHandling(async () => {
-                const initOtpRes = await this.httpClient.proxyInitOtpV2(params);
+                const { otpType, contact, captchaToken } = params;
+                const initOtpRes = await this.httpClient.proxyInitOtpV2({
+                    otpType,
+                    contact,
+                }, captchaToken);
                 if (!initOtpRes ||
                     !initOtpRes.otpId ||
                     !initOtpRes.otpEncryptionTargetBundle) {
@@ -939,12 +946,13 @@ class TurnkeyClient {
          * @param params.createSubOrgParams - parameters for creating a sub-organization (e.g., authenticators, user metadata).
          * @param params.invalidateExisting - flag to invalidate existing session for the user.
          * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+         * @param params.captchaToken - optional captcha token for bot prevention during OTP initialization (must be enabled in the auth proxy config to take effect).
          * @returns A promise that resolves to a {@link BaseAuthResult}, which includes:
          *          - `sessionToken`: the signed JWT session token.
          * @throws {TurnkeyError} If there is an error during the OTP sign-up process or session storage.
          */
         this.signUpWithOtp = async (params) => {
-            const { verificationToken, contact, otpType, createSubOrgParams, invalidateExisting, sessionKey, } = params;
+            const { verificationToken, contact, otpType, createSubOrgParams, invalidateExisting, sessionKey, captchaToken, } = params;
             // build sign up body without client signature first
             const signUpBody = buildSignUpBody({
                 createSubOrgParams: {
@@ -984,7 +992,7 @@ class TurnkeyClient {
                 const signupRes = await this.httpClient.proxySignupV2({
                     ...signUpBody,
                     clientSignature,
-                });
+                }, captchaToken);
                 if (!signupRes) {
                     throw new TurnkeyError(`Auth proxy OTP sign up failed`, TurnkeyErrorCodes.OTP_SIGNUP_ERROR);
                 }
@@ -1021,6 +1029,7 @@ class TurnkeyClient {
          * @param params.invalidateExisting - flag to invalidate existing sessions for the user.
          * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
          * @param params.createSubOrgParams - parameters for sub-organization creation (e.g., authenticators, user metadata).
+         * @param params.captchaToken - optional captcha token for bot prevention during OTP initialization (must be enabled in the auth proxy config to take effect).
          * @returns A promise that resolves to an object containing:
          *          - `sessionToken`: the signed JWT session token.
          *          - `verificationToken`: the OTP verification token.
@@ -1028,7 +1037,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during OTP verification, sign-up, or login.
          */
         this.completeOtp = async (params) => {
-            const { otpId, otpCode, otpEncryptionTargetBundle, contact, otpType, invalidateExisting = false, sessionKey, createSubOrgParams, } = params;
+            const { otpId, otpCode, otpEncryptionTargetBundle, contact, otpType, invalidateExisting = false, sessionKey, createSubOrgParams, captchaToken, } = params;
             const publicKey = params.publicKey ?? (await this.createApiKeyPair());
             if (!publicKey) {
                 throw new TurnkeyError("No public key available. Either pass a publicKey or ensure apiKeyStamper is configured.", TurnkeyErrorCodes.INVALID_REQUEST);
@@ -1060,6 +1069,7 @@ class TurnkeyClient {
                         ...(createSubOrgParams && { createSubOrgParams }),
                         ...(invalidateExisting && { invalidateExisting }),
                         ...(sessionKey && { sessionKey }),
+                        ...(captchaToken && { captchaToken }),
                     });
                     return {
                         ...signUpRes,
@@ -1109,6 +1119,7 @@ class TurnkeyClient {
          * @param params.createSubOrgParams - parameters for sub-organization creation (e.g., authenticators, user metadata).
          * @param params.invalidateExisting - flag to invalidate existing sessions for the user.
          * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+         * @param params.captchaToken - optional captcha token for bot prevention during OAuth completion (must be enabled in the auth proxy config to take effect).
          *
          * @returns A promise that resolves to an object containing:
          *          - `sessionToken`: the signed JWT session token.
@@ -1116,7 +1127,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during the OAuth completion process, such as account lookup, sign-up, or login.
          */
         this.completeOauth = async (params) => {
-            const { oidcToken, publicKey, providerName, createSubOrgParams, invalidateExisting, sessionKey, } = params;
+            const { oidcToken, publicKey, providerName, createSubOrgParams, invalidateExisting, sessionKey, captchaToken, } = params;
             return withTurnkeyErrorHandling(async () => {
                 const accountRes = await this.httpClient.proxyGetAccount({
                     filterType: "OIDC_TOKEN",
@@ -1150,6 +1161,7 @@ class TurnkeyClient {
                         }),
                         ...(invalidateExisting && { invalidateExisting }),
                         ...(sessionKey && { sessionKey }),
+                        ...(captchaToken && { captchaToken }),
                     });
                     return {
                         ...signUpRes,
@@ -1238,12 +1250,13 @@ class TurnkeyClient {
          * @param params.providerName - name of the OAuth provider (e.g., "Google", "Apple").
          * @param params.createSubOrgParams - parameters for sub-organization creation (e.g., authenticators, user metadata).
          * @param params.sessionKey - session key to use for session creation (defaults to the default session key).
+         * @param params.captchaToken - optional captcha token for bot prevention during OTP initialization (must be enabled in the auth proxy config to take effect).
          * @returns A promise that resolves to a {@link BaseAuthResult}, which includes:
          *          - `sessionToken`: the signed JWT session token.
          * @throws {TurnkeyError} If there is an error during the OAuth sign-up or login process.
          */
         this.signUpWithOauth = async (params) => {
-            const { oidcToken, publicKey, providerName = "OpenID Connect Provider" + " " + Date.now(), createSubOrgParams, sessionKey, } = params;
+            const { oidcToken, publicKey, providerName = "OpenID Connect Provider" + " " + Date.now(), createSubOrgParams, sessionKey, captchaToken, } = params;
             return withTurnkeyErrorHandling(async () => {
                 const signUpBody = buildSignUpBody({
                     createSubOrgParams: {
@@ -1257,7 +1270,7 @@ class TurnkeyClient {
                         ],
                     },
                 });
-                const signupRes = await this.httpClient.proxySignupV2(signUpBody);
+                const signupRes = await this.httpClient.proxySignupV2(signUpBody, captchaToken);
                 if (!signupRes) {
                     throw new TurnkeyError(`Auth proxy OAuth signup failed`, TurnkeyErrorCodes.OAUTH_SIGNUP_ERROR);
                 }
@@ -1861,9 +1874,6 @@ class TurnkeyClient {
             });
         };
         /**
-         * @beta
-         * * **API subject to change**
-         *
          * Signs and submits an Ethereum transaction using a Turnkey-managed (embedded) wallet.
          *
          * This method performs **authorization and signing**, and submits the transaction
@@ -1896,44 +1906,23 @@ class TurnkeyClient {
          */
         this.ethSendTransaction = async (params) => {
             const { organizationId: organizationIdFromParams, stampWith = this.config.defaultStamperType, transaction, } = params;
-            const { from, to, caip2, value, data, nonce, gasLimit, maxFeePerGas, maxPriorityFeePerGas, sponsor, gasStationNonce, } = transaction;
             const session = await getActiveSessionOrThrowIfRequired(stampWith, this.storageManager.getActiveSession);
             const organizationId = organizationIdFromParams || session?.organizationId;
             if (!organizationId) {
                 throw new TurnkeyError("Organization ID must be provided to send a transaction", TurnkeyErrorCodes.INVALID_REQUEST);
             }
             return withTurnkeyErrorHandling(async () => {
-                //
-                // Build Turnkey intent
-                //
-                const intent = {
-                    from,
-                    to,
-                    caip2,
-                    ...(value ? { value } : {}),
-                    ...(data ? { data } : {}),
-                    ...(nonce !== undefined ? { nonce } : {}),
-                };
-                if (sponsor) {
-                    intent.sponsor = true;
-                    if (gasStationNonce !== undefined)
-                        intent.gasStationNonce = gasStationNonce;
-                }
-                else {
-                    if (gasLimit)
-                        intent.gasLimit = gasLimit;
-                    if (maxFeePerGas)
-                        intent.maxFeePerGas = maxFeePerGas;
-                    if (maxPriorityFeePerGas)
-                        intent.maxPriorityFeePerGas = maxPriorityFeePerGas;
-                }
-                //
-                // Submit to Turnkey
-                //
-                const resp = await this.httpClient.ethSendTransaction({
-                    ...intent,
-                    organizationId,
-                });
+                // Conditionally call v2 activity if calls array exists.
+                // TODO (breaking change): eventually, we wont generate the v1 activity at all, remove this check and update the intent.
+                const resp = "calls" in transaction
+                    ? await this.httpClient.ethSendTransactionV2({
+                        ...transaction,
+                        organizationId,
+                    })
+                    : await this.httpClient.ethSendTransaction({
+                        ...transaction,
+                        organizationId,
+                    });
                 const id = resp.sendTransactionStatusId;
                 if (!id) {
                     throw new TurnkeyError("Missing sendTransactionStatusId", TurnkeyErrorCodes.ETH_SEND_TRANSACTION_ERROR);
@@ -1945,9 +1934,6 @@ class TurnkeyClient {
             });
         };
         /**
-         * @beta
-         * * **API subject to change**
-         *
          * Signs and submits a Solana transaction using a Turnkey-managed (embedded) wallet.
          *
          * This method performs **authorization and signing**, and submits the transaction
@@ -1982,21 +1968,17 @@ class TurnkeyClient {
                 throw new TurnkeyError("Organization ID must be provided to send a transaction", TurnkeyErrorCodes.INVALID_REQUEST);
             }
             return withTurnkeyErrorHandling(async () => {
-                const intent = {
-                    unsignedTransaction: transaction.unsignedTransaction,
-                    signWith: transaction.signWith,
-                    caip2: transaction.caip2,
-                    ...(transaction.sponsor !== undefined
-                        ? { sponsor: transaction.sponsor }
-                        : {}),
-                    ...(transaction.recentBlockhash
-                        ? { recentBlockhash: transaction.recentBlockhash }
-                        : {}),
-                };
-                const resp = await this.httpClient.solSendTransaction({
-                    ...intent,
-                    organizationId,
-                }, stampWith);
+                // Conditionally call the v2 activity if the signWiths array exists.
+                // TODO (breaking change): eventually, we wont generate the v1 activity at all, remove this check and update the intent.
+                const resp = "signWiths" in transaction
+                    ? await this.httpClient.solSendTransactionV2({
+                        ...transaction,
+                        organizationId,
+                    }, stampWith)
+                    : await this.httpClient.solSendTransaction({
+                        ...transaction,
+                        organizationId,
+                    }, stampWith);
                 const id = resp.sendTransactionStatusId;
                 if (!id) {
                     throw new TurnkeyError("Missing sendTransactionStatusId", TurnkeyErrorCodes.SOL_SEND_TRANSACTION_ERROR);