feat(wallets): add shadow signer support for automatic delegated signers

.changeset/sixty-ladybugs-dance.md

@@ -0,0 +1,7 @@
+---
+"@crossmint/client-sdk-react-ui": minor
+"@crossmint/client-sdk-react-base": minor
+"@crossmint/wallets-sdk": minor
+---
+
+Added Shadow Signers for avoiding redundant OTP Verification

packages/wallets/src/signers/evm-external-wallet.ts

@@ -1,30 +1,18 @@
 import type { Account, EIP1193Provider as ViemEIP1193Provider } from "viem";
-import type { GenericEIP1193Provider, Signer, ExternalWalletInternalSignerConfig } from "./types";
+import type { GenericEIP1193Provider, ExternalWalletInternalSignerConfig } from "./types";
 import type { EVMChain } from "@/chains/chains";
+import { ExternalWalletSigner } from "./external-wallet-signer";
 
-export class EVMExternalWalletSigner implements Signer {
-    type = "external-wallet" as const;
-    private _address: string;
+export class EVMExternalWalletSigner extends ExternalWalletSigner<EVMChain> {
     provider?: GenericEIP1193Provider | ViemEIP1193Provider;
     viemAccount?: Account;
 
-    constructor(private config: ExternalWalletInternalSignerConfig<EVMChain>) {
-        if (config.address == null) {
-            throw new Error("Please provide an address for the External Wallet Signer");
-        }
-        this._address = config.address;
+    constructor(config: ExternalWalletInternalSignerConfig<EVMChain>) {
+        super(config);
         this.provider = config.provider;
         this.viemAccount = config.viemAccount;
     }
 
-    address() {
-        return this._address;
-    }
-
-    locator() {
-        return this.config.locator;
-    }
-
     async signMessage(message: string) {
         if (this.provider != null) {
             const signature = await this.provider.request({

packages/wallets/src/signers/external-wallet-signer.ts

@@ -0,0 +1,25 @@
+import type { ExternalWalletInternalSignerConfig, Signer } from "./types";
+import type { Chain } from "../chains/chains";
+
+export abstract class ExternalWalletSigner<C extends Chain> implements Signer {
+    type = "external-wallet" as const;
+    protected _address: string;
+
+    constructor(protected config: ExternalWalletInternalSignerConfig<C>) {
+        if (config.address == null) {
+            throw new Error("Please provide an address for the External Wallet Signer");
+        }
+        this._address = config.address;
+    }
+
+    address() {
+        return this._address;
+    }
+
+    locator() {
+        return this.config.locator;
+    }
+
+    abstract signMessage(message: string): Promise<{ signature: string }>;
+    abstract signTransaction(transaction: string): Promise<{ signature: string }>;
+}

packages/wallets/src/signers/index.ts

@@ -8,15 +8,19 @@ import type { Chain } from "../chains/chains";
 import type { InternalSignerConfig, Signer } from "./types";
 import { StellarExternalWalletSigner } from "./stellar-external-wallet";
 
-export function assembleSigner<C extends Chain>(chain: C, config: InternalSignerConfig<C>): Signer {
+export function assembleSigner<C extends Chain>(
+    chain: C,
+    config: InternalSignerConfig<C>,
+    walletAddress: string
+): Signer {
     switch (config.type) {
         case "email":
         case "phone":
             if (chain === "solana") {
-                return new SolanaNonCustodialSigner(config);
+                return new SolanaNonCustodialSigner(config, walletAddress);
             }
             if (chain === "stellar") {
-                return new StellarNonCustodialSigner(config);
+                return new StellarNonCustodialSigner(config, walletAddress);
             }
             return new EVMNonCustodialSigner(config);
         case "api-key":

packages/wallets/src/signers/non-custodial/ncs-evm-signer.ts

@@ -1,7 +1,12 @@
-import type { EmailInternalSignerConfig, PhoneInternalSignerConfig } from "../types";
+import type {
+    EmailInternalSignerConfig,
+    ExternalWalletInternalSignerConfig,
+    PhoneInternalSignerConfig,
+} from "../types";
 import { NonCustodialSigner, DEFAULT_EVENT_OPTIONS } from "./ncs-signer";
 import { PersonalMessage } from "ox";
 import { isHex, toHex, type Hex } from "viem";
+import type { EVMChain } from "../../chains/chains";
 
 export class EVMNonCustodialSigner extends NonCustodialSigner {
     constructor(config: EmailInternalSignerConfig | PhoneInternalSignerConfig) {
@@ -64,4 +69,8 @@ export class EVMNonCustodialSigner extends NonCustodialSigner {
             );
         }
     }
+
+    protected getShadowSignerConfig(): ExternalWalletInternalSignerConfig<EVMChain> {
+        throw new Error("Shadow signer not implemented for EVM chains");
+    }
 }

packages/wallets/src/signers/non-custodial/ncs-signer.ts

@@ -1,8 +1,17 @@
-import type { BaseSignResult, EmailInternalSignerConfig, PhoneInternalSignerConfig, Signer } from "../types";
+import type {
+    BaseSignResult,
+    EmailInternalSignerConfig,
+    ExternalWalletInternalSignerConfig,
+    PhoneInternalSignerConfig,
+    Signer,
+} from "../types";
 import { AuthRejectedError } from "../types";
 import { NcsIframeManager } from "./ncs-iframe-manager";
 import { validateAPIKey } from "@crossmint/common-sdk-base";
 import type { SignerOutputEvent } from "@crossmint/client-signers";
+import { getShadowSigner, hasShadowSigner, type ShadowSignerData } from "../shadow-signer";
+import type { Chain } from "../../chains/chains";
+import type { ExternalWalletSigner } from "../external-wallet-signer";
 
 export abstract class NonCustodialSigner implements Signer {
     public readonly type: "email" | "phone";
@@ -13,17 +22,24 @@ export abstract class NonCustodialSigner implements Signer {
         reject: (error: Error) => void;
     } | null = null;
     private _initializationPromise: Promise<void> | null = null;
+    protected shadowSigner: ExternalWalletSigner<Chain> | null = null;
 
     constructor(protected config: EmailInternalSignerConfig | PhoneInternalSignerConfig) {
         this.initialize();
         this.type = this.config.type;
     }
 
     locator() {
+        if (this.shadowSigner != null) {
+            return this.shadowSigner.locator();
+        }
         return this.config.locator;
     }
 
     address() {
+        if (this.shadowSigner != null) {
+            return this.shadowSigner.address();
+        }
         return this.config.address;
     }
 
@@ -83,6 +99,10 @@ export abstract class NonCustodialSigner implements Signer {
     }
 
     protected async handleAuthRequired() {
+        if (this.shadowSigner != null) {
+            return;
+        }
+
         const clientTEEConnection = await this.getTEEConnection();
 
         if (this.config.onAuthRequired == null) {
@@ -267,6 +287,25 @@ export abstract class NonCustodialSigner implements Signer {
         this._authPromise?.reject(error);
         throw error;
     }
+
+    protected abstract getShadowSignerConfig(
+        shadowSigner: ShadowSignerData,
+        walletAddress: string
+    ): ExternalWalletInternalSignerConfig<Chain>;
+
+    protected initializeShadowSigner<C extends Chain>(
+        walletAddress: string,
+        ExternalWalletSignerClass: new (config: ExternalWalletInternalSignerConfig<C>) => ExternalWalletSigner<C>
+    ) {
+        if (hasShadowSigner(walletAddress)) {
+            const shadowSigner = getShadowSigner(walletAddress);
+            if (shadowSigner != null && this.config.shadowSigner?.enabled !== false) {
+                this.shadowSigner = new ExternalWalletSignerClass(
+                    this.getShadowSignerConfig(shadowSigner, walletAddress) as ExternalWalletInternalSignerConfig<C>
+                );
+            }
+        }
+    }
 }
 
 export const DEFAULT_EVENT_OPTIONS = {

packages/wallets/src/signers/non-custodial/ncs-solana-signer.ts

@@ -1,18 +1,29 @@
-import { VersionedTransaction } from "@solana/web3.js";
+import { PublicKey, VersionedTransaction } from "@solana/web3.js";
 import base58 from "bs58";
-import type { EmailInternalSignerConfig, PhoneInternalSignerConfig } from "../types";
+import type {
+    EmailInternalSignerConfig,
+    ExternalWalletInternalSignerConfig,
+    PhoneInternalSignerConfig,
+} from "../types";
 import { NonCustodialSigner, DEFAULT_EVENT_OPTIONS } from "./ncs-signer";
+import { getShadowSignerPrivateKey, type ShadowSignerData } from "../shadow-signer";
+import { SolanaExternalWalletSigner } from "../solana-external-wallet";
+import type { SolanaChain } from "../../chains/chains";
 
 export class SolanaNonCustodialSigner extends NonCustodialSigner {
-    constructor(config: EmailInternalSignerConfig | PhoneInternalSignerConfig) {
+    constructor(config: EmailInternalSignerConfig | PhoneInternalSignerConfig, walletAddress: string) {
         super(config);
+        this.initializeShadowSigner(walletAddress, SolanaExternalWalletSigner);
     }
 
     async signMessage() {
         return await Promise.reject(new Error("signMessage method not implemented for email signer"));
     }
 
     async signTransaction(transaction: string): Promise<{ signature: string }> {
+        if (this.shadowSigner != null) {
+            return await this.shadowSigner.signTransaction(transaction);
+        }
         await this.handleAuthRequired();
         const jwt = this.getJwtOrThrow();
 
@@ -60,4 +71,29 @@ export class SolanaNonCustodialSigner extends NonCustodialSigner {
             );
         }
     }
+
+    protected getShadowSignerConfig(
+        shadowData: ShadowSignerData,
+        walletAddress: string
+    ): ExternalWalletInternalSignerConfig<SolanaChain> {
+        return {
+            type: "external-wallet",
+            address: shadowData.publicKey,
+            locator: `external-wallet:${shadowData.publicKey}`,
+            onSignTransaction: async (transaction) => {
+                const privateKey = await getShadowSignerPrivateKey(walletAddress);
+                if (privateKey == null) {
+                    throw new Error("Shadow signer private key not found");
+                }
+
+                const messageBytes = new Uint8Array(transaction.message.serialize());
+                const signatureBuffer = await window.crypto.subtle.sign({ name: "Ed25519" }, privateKey, messageBytes);
+
+                const signature = new Uint8Array(signatureBuffer);
+                transaction.addSignature(new PublicKey(shadowData.publicKey), signature);
+
+                return transaction;
+            },
+        };
+    }
 }

packages/wallets/src/signers/non-custodial/ncs-stellar-signer.ts

@@ -1,16 +1,27 @@
-import type { EmailInternalSignerConfig, PhoneInternalSignerConfig } from "../types";
+import { getShadowSignerPrivateKey, type ShadowSignerData } from "../shadow-signer";
+import type {
+    EmailInternalSignerConfig,
+    ExternalWalletInternalSignerConfig,
+    PhoneInternalSignerConfig,
+} from "../types";
 import { DEFAULT_EVENT_OPTIONS, NonCustodialSigner } from "./ncs-signer";
+import { StellarExternalWalletSigner } from "../stellar-external-wallet";
+import type { StellarChain } from "../../chains/chains";
 
 export class StellarNonCustodialSigner extends NonCustodialSigner {
-    constructor(config: EmailInternalSignerConfig | PhoneInternalSignerConfig) {
+    constructor(config: EmailInternalSignerConfig | PhoneInternalSignerConfig, walletAddress: string) {
         super(config);
+        this.initializeShadowSigner(walletAddress, StellarExternalWalletSigner);
     }
 
     async signMessage() {
         return await Promise.reject(new Error("signMessage method not implemented for stellar signer"));
     }
 
     async signTransaction(payload: string): Promise<{ signature: string }> {
+        if (this.shadowSigner != null) {
+            return await this.shadowSigner.signTransaction(payload);
+        }
         await this.handleAuthRequired();
         const jwt = this.getJwtOrThrow();
 
@@ -58,4 +69,31 @@ export class StellarNonCustodialSigner extends NonCustodialSigner {
             );
         }
     }
+
+    protected getShadowSignerConfig(
+        shadowData: ShadowSignerData,
+        walletAddress: string
+    ): ExternalWalletInternalSignerConfig<StellarChain> {
+        return {
+            type: "external-wallet",
+            address: shadowData.publicKey,
+            locator: `external-wallet:${shadowData.publicKey}`,
+            onSignStellarTransaction: async (payload) => {
+                const privateKey = await getShadowSignerPrivateKey(walletAddress);
+                if (privateKey == null) {
+                    throw new Error("Shadow signer private key not found");
+                }
+
+                const transactionString = typeof payload === "string" ? payload : (payload as any).tx;
+
+                const messageBytes = Uint8Array.from(atob(transactionString), (c) => c.charCodeAt(0));
+
+                const signatureBuffer = await window.crypto.subtle.sign({ name: "Ed25519" }, privateKey, messageBytes);
+
+                const signature = new Uint8Array(signatureBuffer);
+                const signatureBase64 = btoa(String.fromCharCode(...signature));
+                return signatureBase64;
+            },
+        };
+    }
 }