@rize-labs/paas/dist/PasskeyEoaSigner.js

Passkey management module for all your passkey requirements

"use strict";
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var _PasskeyEoaSigner_publicKey;
Object.defineProperty(exports, "__esModule", { value: true });
exports.PasskeyEoaSigner = void 0;
const ethers_1 = require("ethers");
const WebAuthn_1 = require("./WebAuthn");
const logger_1 = require("@ethersproject/logger");
const ethers_2 = require("ethers");
const Controller_1 = require("./Controller");
const utils_1 = require("ethers/lib/utils");
const WebAuthn_2 = require("./WebAuthn");
const randomMessageGenerator_1 = require("./utils/randomMessageGenerator");
const logger = new logger_1.Logger("abstract-signer/5.7.0");
/**
 * PasskeyEoaSigner
 * It provides methods for initializing, connecting, getting chain ID, getting address,
 * signing transactions, signing messages, and signing typed data using Passkeys.
 */
class PasskeyEoaSigner extends ethers_1.Signer {
    /**
     * Initializes the PasskeyEoaSigner with the given username.
     * @param username The username to initialize with.
     */
    async init(username) {
        const isUserNameUnique = await (0, Controller_1.isUserNameUnqiue)(username);
        let webAuthnConnectionResponse;
        let isUserAuthorized = true;
        if (!isUserNameUnique) {
            webAuthnConnectionResponse = await (0, Controller_1.getPasskeyMeta)(username);
            isUserAuthorized = await (0, WebAuthn_2.checkAuth)((0, randomMessageGenerator_1.generateRandomString)(30), webAuthnConnectionResponse.encodedId, [webAuthnConnectionResponse.q0, webAuthnConnectionResponse.q1]);
        }
        else {
            webAuthnConnectionResponse = await (0, WebAuthn_1.register)();
        }
        if (!isUserAuthorized) {
            throw new Error('You are not authorized to use this wallet');
        }
        __classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").q0 = webAuthnConnectionResponse.q0;
        __classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").q1 = webAuthnConnectionResponse.q1;
        __classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").encodedId = webAuthnConnectionResponse.encodedId;
    }
    constructor(provider, publicKey) {
        super();
        _PasskeyEoaSigner_publicKey.set(this, {});
        this.provider = provider;
        if (publicKey) {
            __classPrivateFieldSet(this, _PasskeyEoaSigner_publicKey, publicKey, "f");
        }
    }
    connect() {
        return logger.throwError("cannot alter JSON-RPC Signer connection", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
            operation: "connect",
        });
    }
    async getChainId() {
        return (await this.provider.getNetwork()).chainId;
    }
    getAddress() {
        const uncompressedPublicKey = `0x04${__classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").q0.slice(2)}${__classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").q1.slice(2)}`;
        const eoaAddress = ethers_2.ethers.utils.computeAddress(uncompressedPublicKey);
        return Promise.resolve(eoaAddress);
    }
    //! mainly signMessage is getting userOp not even sign transaction
    signTransaction(transaction) {
        return logger.throwError("signing transactions is unsupported", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
            operation: "signTransaction",
        });
    }
    async signMessage(message) {
        if (!__classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").encodedId) {
            return Promise.reject(new Error("encoded ID not provided"));
        }
        if (ethers_2.ethers.utils.isBytes(message)) {
            message = ethers_2.ethers.utils.hexlify(message).toString();
        }
        const { signature } = await (0, WebAuthn_1.signMessageViaPassKeys)({
            message: message,
            encodedId: __classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").encodedId,
        });
        return signature;
    }
    async _signTypedData(domain, types, value) {
        const populated = await utils_1._TypedDataEncoder.resolveNames(domain, types, value, async (name) => {
            if (!this.provider) {
                return logger.throwError("cannot resolve ENS names without a provider", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
                    operation: "resolveName",
                    info: { name },
                });
            }
            const address = await this.provider.resolveName(name);
            if (!address) {
                return 'UNCONFIGURED_NAME: unconfigured ENS name';
            }
            return address;
        });
        const hash = utils_1._TypedDataEncoder.hash(populated.domain, types, populated.value);
        const { signature } = await (0, WebAuthn_1.signMessageViaPassKeys)({ message: hash, encodedId: __classPrivateFieldGet(this, _PasskeyEoaSigner_publicKey, "f").encodedId });
        return signature;
    }
}
exports.PasskeyEoaSigner = PasskeyEoaSigner;
_PasskeyEoaSigner_publicKey = new WeakMap();
//# sourceMappingURL=PasskeyEoaSigner.js.map