@turnkey/core 1.10.0 → 1.11.1

package/dist/__clients__/core.d.ts

@@ -1,5 +1,5 @@
 import { TurnkeySDKClientBase } from "../__generated__/sdk-client-base";
-import { type TDeleteSubOrganizationResponse, type Session, type TStampLoginResponse, type v1SignRawPayloadResult, type v1User, type ProxyTGetWalletKitConfigResponse, type v1PrivateKey, type WalletAuthResult, type BaseAuthResult, AuthAction, type PasskeyAuthResult, type v1BootProof, type TGetSendTransactionStatusResponse } from "@turnkey/sdk-types";
+import { type TDeleteSubOrganizationResponse, type Session, type TStampLoginResponse, type v1SignRawPayloadResult, type v1User, type ProxyTGetWalletKitConfigResponse, type v1PrivateKey, type WalletAuthResult, type BaseAuthResult, type PasskeyAuthResult, type v1BootProof, type TGetSendTransactionStatusResponse, AuthAction } from "@turnkey/sdk-types";
 import { Chain, type ExportBundle, type TurnkeySDKClientConfig, type WalletAccount, type Wallet, type WalletManagerBase, type WalletProvider, type CreatePasskeyParams, type CreatePasskeyResult, type LogoutParams, type LoginWithPasskeyParams, type SignUpWithPasskeyParams, type SwitchWalletAccountChainParams, type LoginWithWalletParams, type SignUpWithWalletParams, type LoginOrSignupWithWalletParams, type InitOtpParams, type VerifyOtpParams, type VerifyOtpResult, type LoginWithOtpParams, type SignUpWithOtpParams, type CompleteOtpParams, type CompleteOauthParams, type LoginWithOauthParams, type SignUpWithOauthParams, type FetchWalletsParams, type FetchWalletAccountsParams, type FetchPrivateKeysParams, type SignMessageParams, type SignTransactionParams, type SignAndSendTransactionParams, type EthSendTransactionParams, type FetchUserParams, type FetchOrCreateP256ApiKeyUserParams, type FetchOrCreatePoliciesParams, type FetchOrCreatePoliciesResult, type UpdateUserEmailParams, type RemoveUserEmailParams, type UpdateUserPhoneNumberParams, type RemoveUserPhoneNumberParams, type UpdateUserNameParams, type AddOauthProviderParams, type RemoveOauthProvidersParams, type AddPasskeyParams, type RemovePasskeyParams, type CreateWalletParams, type CreateWalletAccountsParams, type ExportWalletParams, type ExportPrivateKeyParams, type ExportWalletAccountParams, type ImportWalletParams, type ImportPrivateKeyParams, type DeleteSubOrganizationParams, type StoreSessionParams, type ClearSessionParams, type RefreshSessionParams, type GetSessionParams, type SetActiveSessionParams, type CreateApiKeyPairParams, type FetchBootProofForAppProofParams, type CreateHttpClientParams, type BuildWalletLoginRequestResult, type BuildWalletLoginRequestParams, type VerifyAppProofsParams, type PollTransactionStatusParams } from "../__types__";
 import { CrossPlatformApiKeyStamper } from "../__stampers__/api/base";
 import { CrossPlatformPasskeyStamper } from "../__stampers__/passkey/base";
@@ -267,6 +267,7 @@ export declare class TurnkeyClient {
      * @param params.otpCode - OTP code entered by the user.
      * @param params.contact - contact information for the user (e.g., email address or phone number).
      * @param params.otpType - type of OTP being verified (OtpType.Email or OtpType.Sms).
+     * @param params.publicKey - public key the verification token is bound to for ownership verification (client signature verification during login/signup). This public key is optional; if not provided, a new key pair will be generated.
      * @returns A promise that resolves to an object containing:
      *   - subOrganizationId: sub-organization ID if the contact is already associated with a sub-organization, or an empty string if not.
      *   - verificationToken: verification token to be used for login or sign-up.

package/dist/__clients__/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/__clients__/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,OAAO,EACZ,KAAK,mBAAmB,EAExB,KAAK,sBAAsB,EAC3B,KAAK,MAAM,EAGX,KAAK,gCAAgC,EAErC,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,UAAU,EACV,KAAK,iBAAiB,EAEtB,KAAK,WAAW,EAKhB,KAAK,iCAAiC,EACvC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAML,KAAK,EAKL,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,MAAM,EAMX,KAAK,iBAAiB,EACtB,KAAK,cAAc,EAGnB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,8BAA8B,EACnC,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACpB,KAAK,iCAAiC,EACtC,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EACjC,MAAM,cAAc,CAAC;AA8BtB,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAU3E;;;;;;;GAOG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI;KACrB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,aAAa,CAAC,aAAa,CAAC,EAC5B,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,aAAa,CACjD,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,UAAU,EAAG,oBAAoB,CAAC;IAElC,OAAO,CAAC,aAAa,CAAC,CAAyC;IAC/D,OAAO,CAAC,cAAc,CAAC,CAA0C;IACjE,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,cAAc,CAAe;gBAGnC,MAAM,EAAE,sBAAsB,EAG9B,aAAa,CAAC,EAAE,0BAA0B,EAC1C,cAAc,CAAC,EAAE,2BAA2B,EAC5C,aAAa,CAAC,EAAE,iBAAiB;IAY7B,IAAI;IA2CV;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,YACL,sBAAsB,KAC9B,oBAAoB,CAuBrB;IAEF;;;;;;;;;;;OAWG;IACH,aAAa,WACH,mBAAmB,KAC1B,QAAQ,mBAAmB,CAAC,CAuE7B;IAEF;;;;;;;;;;OAUG;IACH,MAAM,YAAmB,YAAY,KAAG,QAAQ,IAAI,CAAC,CA4BnD;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAAgB,YACL,sBAAsB,KAC9B,QAAQ,iBAAiB,CAAC,CAqE3B;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAAiB,YACN,uBAAuB,KAC/B,QAAQ,iBAAiB,CAAC,CA2G3B;IAEF;;;;;;;;;OASG;IACH,oBAAoB,WAAkB,KAAK,KAAG,QAAQ,cAAc,EAAE,CAAC,CAiBrE;IAEF;;;;;;;;OAQG;IACH,oBAAoB,mBACF,cAAc,KAC7B,QAAQ,MAAM,CAAC,CA8BhB;IAEF;;;;;;;;OAQG;IACH,uBAAuB,mBAA0B,cAAc,mBAmB7D;IAEF;;;;;;;;;;;;;;;OAeG;IACH,wBAAwB,WACd,8BAA8B,KACrC,QAAQ,IAAI,CAAC,CAgDd;IAEF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAAuB,WACb,6BAA6B,KACpC,QAAQ,6BAA6B,CAAC,CA2HvC;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,WACL,qBAAqB,KAC5B,QAAQ,gBAAgB,CAAC,CA6E1B;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,WACN,sBAAsB,KAC7B,QAAQ,gBAAgB,CAAC,CAoH1B;IAEF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,uBAAuB,WACb,6BAA6B,KACpC,QAAQ,gBAAgB,GAAG;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,CAAC,CAqGnD;IAEF;;;;;;;;;;;;OAYG;IACH,OAAO,WAAkB,aAAa,KAAG,QAAQ,MAAM,CAAC,CA0BtD;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,WAAkB,eAAe,KAAG,QAAQ,eAAe,CAAC,CA6CnE;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,WACF,kBAAkB,KACzB,QAAQ,cAAc,CAAC,CA6DxB;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,WACH,mBAAmB,KAC1B,QAAQ,cAAc,CAAC,CAiDxB;IAEF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAW,WACD,iBAAiB,KACxB,QACD,cAAc,GAAG;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,CACnE,CA+DC;IAEF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,WACH,mBAAmB,KAC1B,QAAQ,cAAc,GAAG;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,CAAC,CA8DjD;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,WACJ,oBAAoB,KAC3B,QAAQ,cAAc,CAAC,CAwExB;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,WACL,qBAAqB,KAC5B,QAAQ,cAAc,CAAC,CAgDxB;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,YAAmB,kBAAkB,KAAG,QAAQ,MAAM,EAAE,CAAC,CAwLnE;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAAmB,WACT,yBAAyB,KAChC,QAAQ,aAAa,EAAE,CAAC,CAmLzB;IAEF;;;;;;;;;;OAUG;IACH,gBAAgB,YACL,sBAAsB,KAC9B,QAAQ,YAAY,EAAE,CAAC,CAqCxB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,WAAW,WACD,iBAAiB,KACxB,QAAQ,sBAAsB,CAAC,CAiFhC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eAAe,WAAkB,qBAAqB,KAAG,QAAQ,MAAM,CAAC,CAsDtE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,sBAAsB,WACZ,4BAA4B,KACnC,QAAQ,MAAM,CAAC,CAuFhB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,kBAAkB,WACR,wBAAwB,KAC/B,QAAQ,MAAM,CAAC,CAuGhB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IAEG,qBAAqB,CACzB,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,iCAAiC,CAAC;IAkE7C;;;;;;;;;;;;;;OAcG;IACH,SAAS,YAAmB,eAAe,KAAG,QAAQ,MAAM,CAAC,CAgD3D;IAEF;;;;;;;;;;;;;;;OAeG;IACH,2BAA2B,WACjB,iCAAiC,KACxC,QAAQ,MAAM,CAAC,CA6GhB;IAEF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,qBAAqB,WACX,2BAA2B,KAClC,QAAQ,2BAA2B,CAAC,CAuGrC;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,WAAkB,qBAAqB,KAAG,QAAQ,MAAM,CAAC,CA0DtE;IAEF;;;;;;;;;;;;;OAaG;IACH,eAAe,YAAmB,qBAAqB,KAAG,QAAQ,MAAM,CAAC,CAuCvE;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,qBAAqB,WACX,2BAA2B,KAClC,QAAQ,MAAM,CAAC,CA8ChB;IAEF;;;;;;;;;;;;;OAaG;IACH,qBAAqB,YACV,2BAA2B,KACnC,QAAQ,MAAM,CAAC,CAuChB;IAEF;;;;;;;;;;;;;;;OAeG;IACH,cAAc,WAAkB,oBAAoB,KAAG,QAAQ,MAAM,CAAC,CA4CpE;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAAgB,WACN,sBAAsB,KAC7B,QAAQ,MAAM,EAAE,CAAC,CAqGlB;IAEF;;;;;;;;;;;;;;;OAeG;IACH,oBAAoB,WACV,0BAA0B,KACjC,QAAQ,MAAM,EAAE,CAAC,CA0ClB;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,YAAmB,gBAAgB,KAAG,QAAQ,MAAM,EAAE,CAAC,CAqD/D;IAEF;;;;;;;;;;;;;;;OAeG;IACH,cAAc,WAAkB,mBAAmB,KAAG,QAAQ,MAAM,EAAE,CAAC,CA2CrE;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,WAAkB,kBAAkB,KAAG,QAAQ,MAAM,CAAC,CA0DhE;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,oBAAoB,WACV,0BAA0B,KACjC,QAAQ,MAAM,EAAE,CAAC,CAiElB;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,WAAkB,kBAAkB,KAAG,QAAQ,YAAY,CAAC,CA6CtE;IAEF;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,WACN,sBAAsB,KAC7B,QAAQ,YAAY,CAAC,CA4CtB;IAEF;;;;;;;;;;;;;;;;OAgBG;IACH,mBAAmB,WACT,yBAAyB,KAChC,QAAQ,YAAY,CAAC,CA4CtB;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,WAAkB,kBAAkB,KAAG,QAAQ,MAAM,CAAC,CAkEhE;IAEF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBAAgB,WACN,sBAAsB,KAC7B,QAAQ,MAAM,CAAC,CAiEhB;IAEF;;;;;;;;;;;;;;OAcG;IACH,qBAAqB,YACV,2BAA2B,KACnC,QAAQ,8BAA8B,CAAC,CA0BxC;IAEF;;;;;;;;;;;;;OAaG;IACH,YAAY,WAAkB,kBAAkB,KAAG,QAAQ,IAAI,CAAC,CAgB9D;IAEF;;;;;;;;;;;OAWG;IACH,YAAY,YAAmB,kBAAkB,KAAG,QAAQ,IAAI,CAAC,CAsB/D;IAEF;;;;;;;;;;OAUG;IACH,gBAAgB,QAAa,QAAQ,IAAI,CAAC,CAcxC;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,cAAc,YACH,oBAAoB,KAC5B,QAAQ,mBAAmB,GAAG,SAAS,CAAC,CAoEzC;IAEF;;;;;;;;;;OAUG;IACH,UAAU,YACC,gBAAgB,KACxB,QAAQ,OAAO,GAAG,SAAS,CAAC,CAY7B;IAEF;;;;;;;;;;OAUG;IACH,cAAc,QAAa,QAAQ,OAAO,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAqBrE;IAEF;;;;;;;;;;;OAWG;IACH,gBAAgB,WAAkB,sBAAsB,KAAG,QAAQ,IAAI,CAAC,CAWtE;IAEF;;;;;;;;;;OAUG;IACH,mBAAmB,QAAa,QAAQ,MAAM,GAAG,SAAS,CAAC,CAUzD;IAEF;;;;;;;;;;OAUG;IACH,mBAAmB,QAAa,QAAQ,IAAI,CAAC,CAoC3C;IAEF;;;;;;;;;;;;;OAaG;IACH,gBAAgB,YACL,sBAAsB,KAC9B,QAAQ,MAAM,CAAC,CA2BhB;IAEF;;;;;;;;;;OAUG;IACH,kBAAkB,QAAa,QAAQ,gCAAgC,CAAC,CAmBtE;IAEF;;;;;;;;;;;;;OAaG;IACH,yBAAyB,WACf,+BAA+B,KACtC,QAAQ,WAAW,CAAC,CAoDrB;IAEF;;;;;;;;;;OAUG;IACH,eAAe,WAAkB,qBAAqB,KAAG,QAAQ,IAAI,CAAC,CA+DpE;CACH"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/__clients__/core.ts"],"names":[],"mappings":"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"}

package/dist/__clients__/core.js

@@ -13,11 +13,12 @@ var jwtDecode = require('jwt-decode');
 var base$3 = require('../__wallet__/base.js');
 var ethers = require('ethers');
 var crypto = require('@turnkey/crypto');
+var apiKeyStamper = require('@turnkey/api-key-stamper');
 
 class TurnkeyClient {
     constructor(config, 
     // Users can pass in their own stampers, or we will create them. Should we remove this?
-    apiKeyStamper, passkeyStamper, walletManager) {
+    apiKeyStamper$1, passkeyStamper, walletManager) {
         /**
          * Creates a new TurnkeySDKClientBase instance with the provided configuration.
          * This method is used internally to create the HTTP client for making API requests,
@@ -489,28 +490,12 @@ class TurnkeyClient {
                 if (!signedRequest) {
                     throw new sdkTypes.TurnkeyError("Failed to create stamped request for wallet login", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
-                let publicKey;
-                switch (walletProvider.chainInfo.namespace) {
-                    case enums.Chain.Ethereum: {
-                        // for Ethereum, there is no way to get the public key from the wallet address
-                        // so we derive it from the signed request
-                        publicKey = utils.getPublicKeyFromStampHeader(signedRequest.stamp.stampHeaderValue);
-                        break;
-                    }
-                    case enums.Chain.Solana: {
-                        // for Solana, we can get the public key from the wallet address
-                        // since the wallet address is the public key
-                        // this doesn't require any action from the user as long as the wallet is connected
-                        // which it has to be since they just called stampStampLogin()
-                        publicKey = await this.walletManager.stamper.getPublicKey(walletProvider.interfaceType, walletProvider);
-                        break;
-                    }
-                    default:
-                        throw new sdkTypes.TurnkeyError(`Unsupported interface type: ${walletProvider.interfaceType}`, sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
-                }
+                // the wallet's public key is embedded in the stamp header by the wallet stamper
+                // so we extract it from there
+                const publicKey = utils.getPublicKeyFromStampHeader(signedRequest.stamp.stampHeaderValue);
                 return {
                     signedRequest,
-                    publicKey: publicKey,
+                    publicKey,
                 };
             }, {
                 errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_BUILD_LOGIN_REQUEST_ERROR,
@@ -547,49 +532,25 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If the wallet stamper is uninitialized, a public key cannot be found or generated, or login fails.
          */
         this.loginWithWallet = async (params) => {
-            let generatedPublicKey = params.publicKey || (await this.apiKeyStamper?.createKeyPair());
+            const { walletProvider, sessionKey = enums.SessionKey.DefaultSessionkey } = params;
             return utils.withTurnkeyErrorHandling(async () => {
-                if (!this.walletManager?.stamper) {
-                    throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-                }
-                const sessionKey = params.sessionKey || enums.SessionKey.DefaultSessionkey;
-                const walletProvider = params.walletProvider;
-                const expirationSeconds = params?.expirationSeconds || auth.DEFAULT_SESSION_EXPIRATION_IN_SECONDS;
-                if (!generatedPublicKey) {
-                    throw new sdkTypes.TurnkeyError("A publickey could not be found or generated.", sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
+                const { signedRequest, publicKey } = await this.buildWalletLoginRequest(params);
+                const sessionResponse = await this.httpClient.sendSignedRequest(signedRequest);
+                const sessionToken = sessionResponse.session;
+                if (!sessionToken) {
+                    throw new sdkTypes.TurnkeyError("Session token not found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
-                this.walletManager.stamper.setProvider(walletProvider.interfaceType, walletProvider);
-                const sessionResponse = await this.httpClient.stampLogin({
-                    publicKey: generatedPublicKey,
-                    organizationId: params?.organizationId ?? this.config.organizationId,
-                    expirationSeconds,
-                }, enums.StamperType.Wallet);
                 await this.storeSession({
                     sessionToken: sessionResponse.session,
                     sessionKey,
                 });
-                // TODO (Moe): What happens if a user connects to MetaMask on Ethereum,
-                // then switches to a Solana account within MetaMask? Will this flow break?
-                const address = utils.addressFromPublicKey(walletProvider.chainInfo.namespace, generatedPublicKey);
-                generatedPublicKey = undefined; // Key pair was successfully used, set to null to prevent cleanup
                 return {
                     sessionToken: sessionResponse.session,
-                    address,
+                    address: utils.addressFromPublicKey(walletProvider.chainInfo.namespace, publicKey),
                 };
             }, {
                 errorMessage: "Unable to log in with the provided wallet",
                 errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_AUTH_ERROR,
-            }, {
-                finallyFn: async () => {
-                    if (generatedPublicKey) {
-                        try {
-                            await this.apiKeyStamper?.deleteKeyPair(generatedPublicKey);
-                        }
-                        catch (cleanupError) {
-                            throw new sdkTypes.TurnkeyError("Failed to clean up generated key pair", sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
-                        }
-                    }
-                },
             });
         };
         /**
@@ -612,18 +573,9 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during wallet authentication, sub-organization creation, session storage, or cleanup.
          */
         this.signUpWithWallet = async (params) => {
-            const { walletProvider, createSubOrgParams, sessionKey = enums.SessionKey.DefaultSessionkey, expirationSeconds = auth.DEFAULT_SESSION_EXPIRATION_IN_SECONDS, } = params;
-            let generatedPublicKey = undefined;
+            const { walletProvider, createSubOrgParams, sessionKey = enums.SessionKey.DefaultSessionkey, } = params;
             return utils.withTurnkeyErrorHandling(async () => {
-                if (!this.walletManager?.stamper) {
-                    throw new sdkTypes.TurnkeyError("Wallet stamper is not initialized", sdkTypes.TurnkeyErrorCodes.WALLET_MANAGER_COMPONENT_NOT_INITIALIZED);
-                }
-                generatedPublicKey = await this.apiKeyStamper?.createKeyPair();
-                this.walletManager.stamper.setProvider(walletProvider.interfaceType, walletProvider);
-                const publicKey = await this.walletManager.stamper.getPublicKey(walletProvider.interfaceType, walletProvider);
-                if (!publicKey) {
-                    throw new sdkTypes.TurnkeyError("Failed to get public key from wallet", sdkTypes.TurnkeyErrorCodes.WALLET_SIGNUP_AUTH_ERROR);
-                }
+                const { signedRequest, publicKey } = await this.buildWalletLoginRequest(params);
                 const signUpBody = utils.buildSignUpBody({
                     createSubOrgParams: {
                         ...createSubOrgParams,
@@ -633,12 +585,6 @@ class TurnkeyClient {
                                 publicKey: publicKey,
                                 curveType: utils.getCurveTypeFromProvider(walletProvider),
                             },
-                            {
-                                apiKeyName: `wallet-auth-${generatedPublicKey}`,
-                                publicKey: generatedPublicKey,
-                                curveType: "API_KEY_CURVE_P256",
-                                expirationSeconds: "60",
-                            },
                         ],
                     },
                 });
@@ -646,43 +592,24 @@ class TurnkeyClient {
                 if (!res) {
                     throw new sdkTypes.TurnkeyError(`Sign up failed`, sdkTypes.TurnkeyErrorCodes.WALLET_SIGNUP_AUTH_ERROR);
                 }
-                const newGeneratedKeyPair = await this.apiKeyStamper?.createKeyPair();
-                this.apiKeyStamper?.setTemporaryPublicKey(generatedPublicKey);
-                const sessionResponse = await this.httpClient.stampLogin({
-                    publicKey: newGeneratedKeyPair,
-                    organizationId: this.config.organizationId,
-                    expirationSeconds,
+                // now we can send the stamped request to Turnkey
+                const sessionResponse = await this.httpClient.sendSignedRequest(signedRequest);
+                const sessionToken = sessionResponse.session;
+                if (!sessionToken) {
+                    throw new sdkTypes.TurnkeyError("Session token not found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
+                }
+                await this.storeSession({
+                    sessionToken: sessionToken,
+                    sessionKey,
                 });
-                await Promise.all([
-                    this.apiKeyStamper?.deleteKeyPair(generatedPublicKey),
-                    this.storeSession({
-                        sessionToken: sessionResponse.session,
-                        sessionKey,
-                    }),
-                ]);
-                generatedPublicKey = undefined; // Key pair was successfully used, set to null to prevent cleanup
-                // TODO (Moe): What happens if a user connects to MetaMask on Ethereum,
-                // then switches to a Solana account within MetaMask? Will this flow break?
                 return {
-                    sessionToken: sessionResponse.session,
+                    sessionToken: sessionToken,
                     appProofs: res.appProofs,
                     address: utils.addressFromPublicKey(walletProvider.chainInfo.namespace, publicKey),
                 };
             }, {
                 errorMessage: "Failed to sign up with wallet",
                 errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_SIGNUP_AUTH_ERROR,
-            }, {
-                finallyFn: async () => {
-                    this.apiKeyStamper?.clearTemporaryPublicKey();
-                    if (generatedPublicKey) {
-                        try {
-                            await this.apiKeyStamper?.deleteKeyPair(generatedPublicKey);
-                        }
-                        catch (cleanupError) {
-                            throw new sdkTypes.TurnkeyError("Failed to clean up generated key pair", sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
-                        }
-                    }
-                },
             });
         };
         /**
@@ -708,9 +635,7 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during wallet authentication, sub-organization creation, or session storage.
          */
         this.loginOrSignupWithWallet = async (params) => {
-            const createSubOrgParams = params.createSubOrgParams;
-            const sessionKey = params.sessionKey || enums.SessionKey.DefaultSessionkey;
-            const walletProvider = params.walletProvider;
+            const { walletProvider, createSubOrgParams, sessionKey = enums.SessionKey.DefaultSessionkey, } = params;
             return utils.withTurnkeyErrorHandling(async () => {
                 const { signedRequest, publicKey } = await this.buildWalletLoginRequest(params);
                 // here we check if the subOrg exists and create one
@@ -744,8 +669,8 @@ class TurnkeyClient {
                     }
                 }
                 // now we can send the stamped request to Turnkey
-                const sessionResponse = await utils.sendSignedRequest(signedRequest);
-                const sessionToken = sessionResponse.activity.result.stampLoginResult?.session;
+                const sessionResponse = await this.httpClient.sendSignedRequest(signedRequest);
+                const sessionToken = sessionResponse.session;
                 if (!sessionToken) {
                     throw new sdkTypes.TurnkeyError("Session token not found in the response", sdkTypes.TurnkeyErrorCodes.BAD_RESPONSE);
                 }
@@ -763,8 +688,6 @@ class TurnkeyClient {
             }, {
                 errorCode: sdkTypes.TurnkeyErrorCodes.WALLET_LOGIN_OR_SIGNUP_ERROR,
                 errorMessage: "Failed to log in or sign up with wallet",
-                catchFn: async () => {
-                },
             });
         };
         /**
@@ -810,6 +733,7 @@ class TurnkeyClient {
          * @param params.otpCode - OTP code entered by the user.
          * @param params.contact - contact information for the user (e.g., email address or phone number).
          * @param params.otpType - type of OTP being verified (OtpType.Email or OtpType.Sms).
+         * @param params.publicKey - public key the verification token is bound to for ownership verification (client signature verification during login/signup). This public key is optional; if not provided, a new key pair will be generated.
          * @returns A promise that resolves to an object containing:
          *   - subOrganizationId: sub-organization ID if the contact is already associated with a sub-organization, or an empty string if not.
          *   - verificationToken: verification token to be used for login or sign-up.
@@ -817,10 +741,12 @@ class TurnkeyClient {
          */
         this.verifyOtp = async (params) => {
             const { otpId, otpCode, contact, otpType } = params;
+            const resolvedPublicKey = params.publicKey ?? (await this.apiKeyStamper?.createKeyPair());
             return utils.withTurnkeyErrorHandling(async () => {
                 const verifyOtpRes = await this.httpClient.proxyVerifyOtp({
                     otpId: otpId,
                     otpCode: otpCode,
+                    publicKey: resolvedPublicKey,
                 });
                 if (!verifyOtpRes) {
                     throw new sdkTypes.TurnkeyError(`OTP verification failed`, sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
@@ -828,6 +754,7 @@ class TurnkeyClient {
                 const accountRes = await this.httpClient.proxyGetAccount({
                     filterType: enums.OtpTypeToFilterTypeMap[otpType],
                     filterValue: contact,
+                    verificationToken: verifyOtpRes.verificationToken,
                 });
                 if (!accountRes) {
                     throw new sdkTypes.TurnkeyError(`Account fetch failed`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_FETCH_ERROR);
@@ -869,10 +796,26 @@ class TurnkeyClient {
         this.loginWithOtp = async (params) => {
             const { verificationToken, invalidateExisting = false, publicKey = await this.apiKeyStamper?.createKeyPair(), organizationId, sessionKey = enums.SessionKey.DefaultSessionkey, } = params;
             return utils.withTurnkeyErrorHandling(async () => {
+                const { message, publicKey: clientSignaturePublicKey } = utils.getClientSignatureMessageForLogin({
+                    verificationToken,
+                    sessionPublicKey: publicKey,
+                });
+                this.apiKeyStamper?.setTemporaryPublicKey(publicKey);
+                const signature = await this.apiKeyStamper?.sign(message, apiKeyStamper.SignatureFormat.Raw);
+                if (!signature) {
+                    throw new sdkTypes.TurnkeyError(`Failed to sign client signature for OTP login`, sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
+                }
+                const clientSignature = {
+                    message: message,
+                    publicKey: clientSignaturePublicKey,
+                    scheme: "CLIENT_SIGNATURE_SCHEME_API_P256",
+                    signature: signature,
+                };
                 const res = await this.httpClient.proxyOtpLogin({
                     verificationToken,
                     publicKey: publicKey,
                     invalidateExisting,
+                    clientSignature,
                     ...(organizationId && { organizationId }),
                 });
                 if (!res) {
@@ -903,6 +846,10 @@ class TurnkeyClient {
                         }
                     }
                 },
+            }, {
+                finallyFn: async () => {
+                    this.apiKeyStamper?.clearTemporaryPublicKey();
+                },
             });
         };
         /**
@@ -925,7 +872,8 @@ class TurnkeyClient {
          * @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, publicKey = await this.apiKeyStamper?.createKeyPair(), } = params;
+            // build sign up body without client signature first
             const signUpBody = utils.buildSignUpBody({
                 createSubOrgParams: {
                     ...createSubOrgParams,
@@ -936,14 +884,37 @@ class TurnkeyClient {
                 },
             });
             return utils.withTurnkeyErrorHandling(async () => {
-                const generatedPublicKey = await this.apiKeyStamper?.createKeyPair();
-                const signupRes = await this.httpClient.proxySignup(signUpBody);
+                const { message, publicKey: clientSignaturePublicKey } = utils.getClientSignatureMessageForSignup({
+                    verificationToken,
+                    ...(signUpBody.userEmail && { email: signUpBody.userEmail }),
+                    ...(signUpBody.userPhoneNumber && {
+                        phoneNumber: signUpBody.userPhoneNumber,
+                    }),
+                    apiKeys: signUpBody.apiKeys,
+                    authenticators: signUpBody.authenticators,
+                    oauthProviders: signUpBody.oauthProviders,
+                });
+                this.apiKeyStamper?.setTemporaryPublicKey(publicKey);
+                const signature = await this.apiKeyStamper?.sign(message, apiKeyStamper.SignatureFormat.Raw);
+                if (!signature) {
+                    throw new sdkTypes.TurnkeyError(`Failed to sign client signature for OTP sign up`, sdkTypes.TurnkeyErrorCodes.INTERNAL_ERROR);
+                }
+                const clientSignature = {
+                    message: message,
+                    publicKey: clientSignaturePublicKey,
+                    scheme: "CLIENT_SIGNATURE_SCHEME_API_P256",
+                    signature: signature,
+                };
+                const signupRes = await this.httpClient.proxySignup({
+                    ...signUpBody,
+                    clientSignature,
+                });
                 if (!signupRes) {
                     throw new sdkTypes.TurnkeyError(`Auth proxy OTP sign up failed`, sdkTypes.TurnkeyErrorCodes.OTP_SIGNUP_ERROR);
                 }
                 const otpRes = await this.loginWithOtp({
                     verificationToken,
-                    publicKey: generatedPublicKey,
+                    publicKey: publicKey,
                     ...(invalidateExisting && { invalidateExisting }),
                     ...(sessionKey && { sessionKey }),
                 });
@@ -952,8 +923,23 @@ class TurnkeyClient {
                     appProofs: signupRes.appProofs,
                 };
             }, {
+                catchFn: async () => {
+                    // Clean up the generated key pair if it wasn't successfully used
+                    if (publicKey) {
+                        try {
+                            await this.apiKeyStamper?.deleteKeyPair(publicKey);
+                        }
+                        catch (cleanupError) {
+                            throw new sdkTypes.TurnkeyError(`Failed to clean up generated key pair`, sdkTypes.TurnkeyErrorCodes.KEY_PAIR_CLEANUP_ERROR, cleanupError);
+                        }
+                    }
+                },
                 errorCode: sdkTypes.TurnkeyErrorCodes.OTP_SIGNUP_ERROR,
                 errorMessage: "Failed to sign up with OTP",
+            }, {
+                finallyFn: async () => {
+                    this.apiKeyStamper?.clearTemporaryPublicKey();
+                },
             });
         };
         /**
@@ -980,13 +966,14 @@ class TurnkeyClient {
          * @throws {TurnkeyError} If there is an error during OTP verification, sign-up, or login.
          */
         this.completeOtp = async (params) => {
-            const { otpId, otpCode, contact, otpType, publicKey, invalidateExisting = false, sessionKey, createSubOrgParams, } = params;
+            const { otpId, otpCode, contact, otpType, publicKey = await this.apiKeyStamper?.createKeyPair(), invalidateExisting = false, sessionKey, createSubOrgParams, } = params;
             return utils.withTurnkeyErrorHandling(async () => {
                 const { subOrganizationId, verificationToken } = await this.verifyOtp({
                     otpId: otpId,
                     otpCode: otpCode,
                     contact: contact,
                     otpType: otpType,
+                    publicKey: publicKey,
                 });
                 if (!verificationToken) {
                     throw new sdkTypes.TurnkeyError("No verification token returned from OTP verification", sdkTypes.TurnkeyErrorCodes.VERIFY_OTP_ERROR);
@@ -999,6 +986,7 @@ class TurnkeyClient {
                         ...(createSubOrgParams && { createSubOrgParams }),
                         ...(invalidateExisting && { invalidateExisting }),
                         ...(sessionKey && { sessionKey }),
+                        publicKey: publicKey,
                     });
                     return {
                         ...signUpRes,
@@ -1009,7 +997,7 @@ class TurnkeyClient {
                 else {
                     const loginRes = await this.loginWithOtp({
                         verificationToken,
-                        ...(publicKey && { publicKey }),
+                        publicKey: publicKey,
                         ...(invalidateExisting && { invalidateExisting }),
                         ...(sessionKey && { sessionKey }),
                     });
@@ -1247,7 +1235,9 @@ class TurnkeyClient {
                     if (!signedUserRequest) {
                         throw new sdkTypes.TurnkeyError("Failed to stamp user request", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
                     }
-                    userPromise = utils.sendSignedRequest(signedUserRequest).then((response) => utils.getAuthenticatorAddresses(response.user));
+                    userPromise = this.httpClient
+                        .sendSignedRequest(signedUserRequest)
+                        .then((response) => utils.getAuthenticatorAddresses(response.user));
                 }
                 // if connectedOnly is true, we skip fetching embedded wallets
                 if (!connectedOnly) {
@@ -1267,7 +1257,7 @@ class TurnkeyClient {
                     }
                     const [accounts, walletsRes] = await Promise.all([
                         utils.fetchAllWalletAccountsWithCursor(this.httpClient, organizationId, stampWith),
-                        utils.sendSignedRequest(signedWalletsRequest),
+                        this.httpClient.sendSignedRequest(signedWalletsRequest),
                     ]);
                     // create a map of walletId to EmbeddedWallet for easy lookup
                     const walletMap = new Map(walletsRes.wallets.map((wallet) => [
@@ -2062,12 +2052,15 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("User ID must be provided to update user email", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
             }
             return utils.withTurnkeyErrorHandling(async () => {
-                const existingUser = await this.httpClient.proxyGetAccount({
-                    filterType: enums.FilterType.Email,
-                    filterValue: email,
-                });
-                if (existingUser.organizationId) {
-                    throw new sdkTypes.TurnkeyError(`Email ${email} is already associated with another user.`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_ALREADY_EXISTS);
+                if (verificationToken) {
+                    const existingUser = await this.httpClient.proxyGetAccount({
+                        filterType: enums.FilterType.Email,
+                        filterValue: email,
+                        verificationToken,
+                    });
+                    if (existingUser.organizationId) {
+                        throw new sdkTypes.TurnkeyError(`Email ${email} is already associated with another user.`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_ALREADY_EXISTS);
+                    }
                 }
                 const res = await this.httpClient.updateUserEmail({
                     userId: userId,
@@ -2145,6 +2138,16 @@ class TurnkeyClient {
                 throw new sdkTypes.TurnkeyError("User ID must be provided to update user phone number", sdkTypes.TurnkeyErrorCodes.INVALID_REQUEST);
             }
             return utils.withTurnkeyErrorHandling(async () => {
+                if (verificationToken) {
+                    const existingUser = await this.httpClient.proxyGetAccount({
+                        filterType: enums.FilterType.Sms,
+                        filterValue: phoneNumber,
+                        verificationToken,
+                    });
+                    if (existingUser.organizationId) {
+                        throw new sdkTypes.TurnkeyError(`Phone number ${phoneNumber} is already associated with another user.`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_ALREADY_EXISTS);
+                    }
+                }
                 const res = await this.httpClient.updateUserPhoneNumber({
                     userId,
                     userPhoneNumber: phoneNumber,
@@ -2263,7 +2266,8 @@ class TurnkeyClient {
                 if (!accountRes) {
                     throw new sdkTypes.TurnkeyError(`Account fetch failed`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_FETCH_ERROR);
                 }
-                if (accountRes.organizationId) {
+                if (accountRes.organizationId &&
+                    accountRes.organizationId !== session?.organizationId) {
                     throw new sdkTypes.TurnkeyError("Account already exists with this OIDC token", sdkTypes.TurnkeyErrorCodes.ACCOUNT_ALREADY_EXISTS);
                 }
                 const userId = params?.userId || session?.userId;
@@ -2280,18 +2284,33 @@ class TurnkeyClient {
                     const verifiedSuborg = await this.httpClient.proxyGetAccount({
                         filterType: "EMAIL",
                         filterValue: oidcEmail,
+                        oidcToken: oidcToken,
                     });
                     const isVerified = verifiedSuborg.organizationId === organizationId;
                     const user = await this.fetchUser({
                         userId,
                         stampWith,
                     });
+                    // this block's pupose is for social linking, it's important that we update the email BEFORE we call createOauthProviders
+                    // since for social linking createOauthProviders will mark the email as verified as long as it's the same one that lives in the
+                    // OIDC token.
                     if (!user?.userEmail && !isVerified) {
-                        await this.updateUserEmail({
-                            email: oidcEmail,
-                            userId,
-                            stampWith,
+                        // we cannot use our sugared updateUserEmail here since we need to pass in the oidcToken in case Require Verification Token On Account Lookup is enabled
+                        // in the dashboard
+                        const existingUser = await this.httpClient.proxyGetAccount({
+                            filterType: enums.FilterType.Email,
+                            filterValue: oidcEmail,
+                            oidcToken: oidcToken,
                         });
+                        if (existingUser.organizationId) {
+                            throw new sdkTypes.TurnkeyError(`Email ${oidcEmail} is already associated with another user.`, sdkTypes.TurnkeyErrorCodes.ACCOUNT_ALREADY_EXISTS);
+                        }
+                        // update and verify their email since we got it from a verified OIDC token
+                        await this.httpClient.updateUserEmail({
+                            userId,
+                            userEmail: oidcEmail,
+                            organizationId,
+                        }, stampWith);
                     }
                 }
                 const createProviderRes = await this.httpClient.createOauthProviders({
@@ -3211,7 +3230,7 @@ class TurnkeyClient {
         };
         this.config = config;
         // Just store any explicitly provided stampers
-        this.apiKeyStamper = apiKeyStamper;
+        this.apiKeyStamper = apiKeyStamper$1;
         this.passkeyStamper = passkeyStamper;
         this.walletManager = walletManager;
         // Actual initialization will happen in init()