@account-kit/react-native-signer 4.1.8-alpha

package/lib/typescript/module/src/client.d.ts

@@ -0,0 +1,107 @@
+import "./utils/mmkv-localstorage-polyfill";
+import { BaseSignerClient, type AlchemySignerClientEvents, type AuthenticatingEventMetadata, type CreateAccountParams, type EmailAuthParams, type GetWebAuthnAttestationResult, type OauthConfig, type OauthParams, type SignupResponse, type User } from "@account-kit/signer";
+import { z } from "zod";
+export declare const RNSignerClientParamsSchema: z.ZodObject<{
+    connection: z.ZodType<{
+        apiKey: string;
+        rpcUrl?: undefined;
+        jwt?: undefined;
+    } | {
+        jwt: string;
+        rpcUrl?: undefined;
+        apiKey?: undefined;
+    } | {
+        rpcUrl: string;
+        apiKey?: undefined;
+        jwt?: undefined;
+    } | {
+        rpcUrl: string;
+        jwt: string;
+        apiKey?: undefined;
+    }, z.ZodTypeDef, {
+        apiKey: string;
+        rpcUrl?: undefined;
+        jwt?: undefined;
+    } | {
+        jwt: string;
+        rpcUrl?: undefined;
+        apiKey?: undefined;
+    } | {
+        rpcUrl: string;
+        apiKey?: undefined;
+        jwt?: undefined;
+    } | {
+        rpcUrl: string;
+        jwt: string;
+        apiKey?: undefined;
+    }>;
+    rootOrgId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    connection: {
+        apiKey: string;
+        rpcUrl?: undefined;
+        jwt?: undefined;
+    } | {
+        jwt: string;
+        rpcUrl?: undefined;
+        apiKey?: undefined;
+    } | {
+        rpcUrl: string;
+        apiKey?: undefined;
+        jwt?: undefined;
+    } | {
+        rpcUrl: string;
+        jwt: string;
+        apiKey?: undefined;
+    };
+    rootOrgId?: string | undefined;
+}, {
+    connection: {
+        apiKey: string;
+        rpcUrl?: undefined;
+        jwt?: undefined;
+    } | {
+        jwt: string;
+        rpcUrl?: undefined;
+        apiKey?: undefined;
+    } | {
+        rpcUrl: string;
+        apiKey?: undefined;
+        jwt?: undefined;
+    } | {
+        rpcUrl: string;
+        jwt: string;
+        apiKey?: undefined;
+    };
+    rootOrgId?: string | undefined;
+}>;
+export type RNSignerClientParams = z.input<typeof RNSignerClientParamsSchema>;
+export declare class RNSignerClient extends BaseSignerClient<undefined> {
+    private stamper;
+    constructor(params: RNSignerClientParams);
+    createAccount(params: CreateAccountParams): Promise<SignupResponse>;
+    initEmailAuth(params: Omit<EmailAuthParams, "targetPublicKey">): Promise<{
+        orgId: string;
+    }>;
+    completeAuthWithBundle(params: {
+        bundle: string;
+        orgId: string;
+        connectedEventName: keyof AlchemySignerClientEvents;
+        authenticatingType: AuthenticatingEventMetadata["type"];
+        idToken?: string;
+    }): Promise<User>;
+    oauthWithRedirect(_args: Extract<OauthParams, {
+        mode: "redirect";
+    }>): Promise<never>;
+    oauthWithPopup(_args: Extract<OauthParams, {
+        mode: "popup";
+    }>): Promise<User>;
+    disconnect(): Promise<void>;
+    exportWallet(_params: unknown): Promise<boolean>;
+    lookupUserWithPasskey(_user?: User): Promise<User>;
+    protected getOauthConfig(): Promise<OauthConfig>;
+    protected getWebAuthnAttestation(_options: CredentialCreationOptions, _userDetails?: {
+        username: string;
+    }): Promise<GetWebAuthnAttestationResult>;
+}
+//# sourceMappingURL=client.d.ts.map

package/lib/typescript/module/src/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/client.ts"],"names":[],"mappings":"AACA,OAAO,oCAAoC,CAAC;AAE5C,OAAO,EACL,gBAAgB,EAChB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAChC,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,IAAI,EACV,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAG9E,qBAAa,cAAe,SAAQ,gBAAgB,CAAC,SAAS,CAAC;IAC7D,OAAO,CAAC,OAAO,CAAoB;gBACvB,MAAM,EAAE,oBAAoB;IAUzB,aAAa,CAC1B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,cAAc,CAAC;IAmBX,aAAa,CAC1B,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,iBAAiB,CAAC,GAC/C,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAUd,sBAAsB,CAAC,MAAM,EAAE;QAC5C,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;QACpD,kBAAkB,EAAE,2BAA2B,CAAC,MAAM,CAAC,CAAC;QACxD,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBR,iBAAiB,CACxB,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,GAChD,OAAO,CAAC,KAAK,CAAC;IAGR,cAAc,CACrB,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,GAC7C,OAAO,CAAC,IAAI,CAAC;IAID,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAGhD,qBAAqB,CAAC,KAAK,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;cAGxC,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC;cAGtC,sBAAsB,CACvC,QAAQ,EAAE,yBAAyB,EACnC,YAAY,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAClC,OAAO,CAAC,4BAA4B,CAAC;CAGzC"}

package/lib/typescript/module/src/index.d.ts

@@ -0,0 +1,2 @@
+export { RNAlchemySigner } from "./signer";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}

package/lib/typescript/module/src/signer.d.ts

@@ -0,0 +1,185 @@
+import { z } from "zod";
+import { BaseAlchemySigner } from "@account-kit/signer";
+import { RNSignerClient } from "./client";
+declare const RNAlchemySignerParamsSchema: z.ZodObject<{
+    client: z.ZodUnion<[z.ZodType<RNSignerClient, z.ZodTypeDef, RNSignerClient>, z.ZodObject<{
+        connection: z.ZodType<{
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        }, z.ZodTypeDef, {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        }>;
+        rootOrgId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        connection: {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        };
+        rootOrgId?: string | undefined;
+    }, {
+        connection: {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        };
+        rootOrgId?: string | undefined;
+    }>]>;
+    sessionConfig: z.ZodOptional<z.ZodObject<Omit<{
+        sessionKey: z.ZodDefault<z.ZodString>;
+        storage: z.ZodUnion<[z.ZodDefault<z.ZodEnum<["localStorage", "sessionStorage"]>>, z.ZodType<Storage, z.ZodTypeDef, Storage>]>;
+        expirationTimeMs: z.ZodDefault<z.ZodNumber>;
+        client: z.ZodType<import("@account-kit/signer").BaseSignerClient<unknown>, z.ZodTypeDef, import("@account-kit/signer").BaseSignerClient<unknown>>;
+    }, "client" | "storage">, "strip", z.ZodTypeAny, {
+        sessionKey: string;
+        expirationTimeMs: number;
+    }, {
+        sessionKey?: string | undefined;
+        expirationTimeMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    client: ({
+        connection: {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        };
+        rootOrgId?: string | undefined;
+    } | RNSignerClient) & ({
+        connection: {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        };
+        rootOrgId?: string | undefined;
+    } | RNSignerClient | undefined);
+    sessionConfig?: {
+        sessionKey: string;
+        expirationTimeMs: number;
+    } | undefined;
+}, {
+    client: ({
+        connection: {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        };
+        rootOrgId?: string | undefined;
+    } | RNSignerClient) & ({
+        connection: {
+            apiKey: string;
+            rpcUrl?: undefined;
+            jwt?: undefined;
+        } | {
+            jwt: string;
+            rpcUrl?: undefined;
+            apiKey?: undefined;
+        } | {
+            rpcUrl: string;
+            apiKey?: undefined;
+            jwt?: undefined;
+        } | {
+            rpcUrl: string;
+            jwt: string;
+            apiKey?: undefined;
+        };
+        rootOrgId?: string | undefined;
+    } | RNSignerClient | undefined);
+    sessionConfig?: {
+        sessionKey?: string | undefined;
+        expirationTimeMs?: number | undefined;
+    } | undefined;
+}>;
+export type RNAlchemySignerParams = z.input<typeof RNAlchemySignerParamsSchema>;
+export declare class RNAlchemySigner extends BaseAlchemySigner<RNSignerClient> {
+    constructor(params: RNAlchemySignerParams);
+}
+export {};
+//# sourceMappingURL=signer.d.ts.map

package/lib/typescript/module/src/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../../../src/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,iBAAiB,EAElB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,cAAc,EAA8B,MAAM,UAAU,CAAC;AAEtE,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEgC,EAAG,UAElE,CAAC,EAAE,SACH;iBAAe,EAAG,QAAQ,EAAE,EAAE,UAAU,CAAC,EAAE,OAAO,uCAEnC,EACb,OAAE,UAAS,EACb,UAEA;0BAAmC,EAAG,UAAU,CAAC,EAAE,SAAS;gBAAc,EAAG,OAE3E,0DAA2B,EAAG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAJxC,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,qBAAa,eAAgB,SAAQ,iBAAiB,CAAC,cAAc,CAAC;gBACxD,MAAM,EAAE,qBAAqB;CAgB1C"}

package/lib/typescript/module/src/utils/mmkv-localstorage-polyfill.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mmkv-localstorage-polyfill.d.ts.map

package/lib/typescript/module/src/utils/mmkv-localstorage-polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkv-localstorage-polyfill.d.ts","sourceRoot":"","sources":["../../../../../src/utils/mmkv-localstorage-polyfill.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,153 @@
+{
+  "name": "@account-kit/react-native-signer",
+  "version": "4.1.8-alpha",
+  "description": "React Native compatible Account Kit signer",
+  "source": "./src/index.tsx",
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/typescript/module/src/index.d.ts",
+        "default": "./lib/module/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/src/index.d.ts",
+        "default": "./lib/commonjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.json",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "test": "jest",
+    "typecheck": "tsc",
+    "build:rn": "bob build && yarn typecheck && yarn turbo run build:android",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alchemyplatform/aa-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alchemyplatform/aa-sdk/issues"
+  },
+  "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^17.0.2",
+    "@evilmartians/lefthook": "^1.5.0",
+    "@react-native-community/cli": "15.0.0",
+    "@react-native/eslint-config": "^0.73.1",
+    "@release-it/conventional-changelog": "^5.0.0",
+    "@types/jest": "^29.5.5",
+    "@types/react": "^18.2.44",
+    "commitlint": "^17.0.2",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.51.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "react": "18.3.1",
+    "react-native": "0.76.1",
+    "react-native-builder-bob": "^0.30.3",
+    "react-native-mmkv": "^3.1.0",
+    "release-it": "^15.0.0",
+    "turbo": "^1.10.7",
+    "typescript": "^5.2.2",
+    "typescript-template": "*"
+  },
+  "resolutions": {
+    "@types/react": "^18.2.44"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-config": "1.5.3",
+    "react-native-gesture-handler": "2.21.2",
+    "react-native-mmkv": "^3.1.0"
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "codegen",
+      [
+        "commonjs",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json",
+          "esm": true
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "NativeTEKStamperSpec",
+    "type": "all",
+    "jsSrcsDir": "src",
+    "outputDir": {
+      "ios": "ios/generated",
+      "android": "android/generated"
+    },
+    "android": {
+      "javaPackageName": "com.accountkit.reactnativesigner"
+    },
+    "includesGeneratedCode": true
+  },
+  "create-react-native-library": {
+    "type": "module-new",
+    "languages": "kotlin-objc",
+    "version": "0.42.2"
+  },
+  "dependencies": {
+    "@aa-sdk/core": "^4.3.0",
+    "@account-kit/signer": "^4.3.0",
+    "viem": "^2.21.40"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+/**
+ */
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        cmakeListsPath: "generated/jni/CMakeLists.txt",
+      },
+    },
+  },
+};

package/src/NativeTEKStamper.ts

@@ -0,0 +1,42 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+type TStamp = {
+  stampHeaderName: string;
+  stampHeaderValue: string;
+};
+
+export interface Spec extends TurboModule {
+  /**
+   * Creates an instance of the stamper and returns the public key of TEK
+   */
+  init(): Promise<string>;
+
+  /**
+   * Clears the stored bundle and TEK
+   */
+  clear(): void;
+
+  /**
+   * Returns the public key, or `null` if the stamper isn't properly initialized.
+   */
+  publicKey(): string | null;
+
+  /**
+   * Function to inject a new credential into the iframe
+   * The bundle should be encrypted to the stamper's initial public key
+   * Encryption should be performed with HPKE (RFC 9180).
+   * This is used during recovery and auth flows.
+   */
+  injectCredentialBundle(bundle: string): Promise<boolean>;
+
+  /**
+   * Function to sign a payload with the underlying credential bundle
+   * Should throw an error if the bundle was never injected
+   */
+  stamp(payload: string): Promise<TStamp>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  "NativeTEKStamper"
+) as Spec;

package/src/client.ts

@@ -0,0 +1,128 @@
+/* eslint-disable import/extensions */
+import "./utils/mmkv-localstorage-polyfill";
+import { type ConnectionConfig } from "@aa-sdk/core";
+import {
+  BaseSignerClient,
+  type AlchemySignerClientEvents,
+  type AuthenticatingEventMetadata,
+  type CreateAccountParams,
+  type EmailAuthParams,
+  type GetWebAuthnAttestationResult,
+  type OauthConfig,
+  type OauthParams,
+  type SignupResponse,
+  type User,
+} from "@account-kit/signer";
+import NativeTEKStamper from "./NativeTEKStamper";
+import { z } from "zod";
+
+export const RNSignerClientParamsSchema = z.object({
+  connection: z.custom<ConnectionConfig>(),
+  rootOrgId: z.string().optional(),
+});
+
+export type RNSignerClientParams = z.input<typeof RNSignerClientParamsSchema>;
+
+// TODO: need to emit events
+export class RNSignerClient extends BaseSignerClient<undefined> {
+  private stamper = NativeTEKStamper;
+  constructor(params: RNSignerClientParams) {
+    const { connection, rootOrgId } = RNSignerClientParamsSchema.parse(params);
+
+    super({
+      stamper: NativeTEKStamper,
+      rootOrgId: rootOrgId ?? "24c1acf5-810f-41e0-a503-d5d13fa8e830",
+      connection,
+    });
+  }
+
+  override async createAccount(
+    params: CreateAccountParams
+  ): Promise<SignupResponse> {
+    if (params.type !== "email") {
+      throw new Error("Only email account creation is supported");
+    }
+
+    this.eventEmitter.emit("authenticating", { type: "email" });
+    const { email, expirationSeconds } = params;
+    const publicKey = await this.stamper.init();
+
+    const response = await this.request("/v1/signup", {
+      email,
+      targetPublicKey: publicKey,
+      expirationSeconds,
+      redirectParams: params.redirectParams?.toString(),
+    });
+
+    return response;
+  }
+
+  override async initEmailAuth(
+    params: Omit<EmailAuthParams, "targetPublicKey">
+  ): Promise<{ orgId: string }> {
+    this.eventEmitter.emit("authenticating", { type: "email" });
+    let targetPublicKey = await this.stamper.init();
+
+    return this.request("/v1/auth", {
+      email: params.email,
+      targetPublicKey,
+    });
+  }
+
+  override async completeAuthWithBundle(params: {
+    bundle: string;
+    orgId: string;
+    connectedEventName: keyof AlchemySignerClientEvents;
+    authenticatingType: AuthenticatingEventMetadata["type"];
+    idToken?: string;
+  }): Promise<User> {
+    if (params.authenticatingType !== "email") {
+      throw new Error("Unsupported authenticating type");
+    }
+
+    this.eventEmitter.emit("authenticating", { type: "email" });
+    await this.stamper.init();
+
+    const result = await this.stamper.injectCredentialBundle(params.bundle);
+
+    if (!result) {
+      throw new Error("Failed to inject credential bundle");
+    }
+
+    const user = await this.whoami(params.orgId, params.idToken);
+
+    this.eventEmitter.emit(params.connectedEventName, user, params.bundle);
+    return user;
+  }
+  override oauthWithRedirect(
+    _args: Extract<OauthParams, { mode: "redirect" }>
+  ): Promise<never> {
+    throw new Error("Method not implemented.");
+  }
+  override oauthWithPopup(
+    _args: Extract<OauthParams, { mode: "popup" }>
+  ): Promise<User> {
+    throw new Error("Method not implemented.");
+  }
+
+  override async disconnect(): Promise<void> {
+    this.user = undefined;
+    this.stamper.clear();
+    await this.stamper.init();
+  }
+  override exportWallet(_params: unknown): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  override lookupUserWithPasskey(_user?: User): Promise<User> {
+    throw new Error("Method not implemented.");
+  }
+  protected override getOauthConfig(): Promise<OauthConfig> {
+    throw new Error("Method not implemented.");
+  }
+  protected override getWebAuthnAttestation(
+    _options: CredentialCreationOptions,
+    _userDetails?: { username: string }
+  ): Promise<GetWebAuthnAttestationResult> {
+    throw new Error("Method not implemented.");
+  }
+}

package/src/index.tsx

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/extensions
+export { RNAlchemySigner } from "./signer";

package/src/signer.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import {
+  BaseAlchemySigner,
+  SessionManagerParamsSchema,
+} from "@account-kit/signer";
+// eslint-disable-next-line import/extensions
+import { RNSignerClient, RNSignerClientParamsSchema } from "./client";
+
+const RNAlchemySignerParamsSchema = z
+  .object({
+    client: z.custom<RNSignerClient>().or(RNSignerClientParamsSchema),
+  })
+  .extend({
+    sessionConfig: SessionManagerParamsSchema.omit({
+      client: true,
+      storage: true,
+    }).optional(),
+  });
+
+export type RNAlchemySignerParams = z.input<typeof RNAlchemySignerParamsSchema>;
+
+export class RNAlchemySigner extends BaseAlchemySigner<RNSignerClient> {
+  constructor(params: RNAlchemySignerParams) {
+    const { sessionConfig, ...params_ } =
+      RNAlchemySignerParamsSchema.parse(params);
+
+    let client: RNSignerClient;
+
+    if ("connection" in params_.client) {
+      client = new RNSignerClient(params_.client);
+    } else {
+      client = params_.client;
+    }
+    super({
+      client,
+      sessionConfig,
+    });
+  }
+}