@abstract-foundation/web3-react-agw/dist/cjs/index.js

Abstract Global Wallet for web3-react

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AbstractGlobalWallet = void 0;
const agw_client_1 = require("@abstract-foundation/agw-client");
const types_1 = require("@web3-react/types");
const chains_1 = require("viem/chains");
const AGW_APP_ID = 'cm04asygd041fmry9zmcyn5o5';
const VALID_CHAINS = {
    [chains_1.abstractTestnet.id]: chains_1.abstractTestnet,
    [chains_1.abstract.id]: chains_1.abstract,
};
function parseChainId(chainId) {
    return typeof chainId === 'string' ? Number.parseInt(chainId, 16) : chainId;
}
class AbstractGlobalWallet extends types_1.Connector {
    constructor({ actions, onError }) {
        super(actions, onError);
        Object.defineProperty(this, "eagerConnection", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
    }
    async isomorphicInitialize() {
        if (this.eagerConnection)
            return;
        return (this.eagerConnection = Promise.resolve().then(() => require('@privy-io/cross-app-connect')).then(async ({ toPrivyWalletProvider }) => {
            const originalProvider = toPrivyWalletProvider({
                providerAppId: AGW_APP_ID,
                chains: [chains_1.abstractTestnet],
            });
            const agwProvider = (0, agw_client_1.transformEIP1193Provider)({
                provider: originalProvider,
                chain: chains_1.abstractTestnet,
            });
            if (agwProvider) {
                this.provider = agwProvider;
                this.provider.on('connect', ({ chainId }) => {
                    this.actions.update({ chainId: parseChainId(chainId) });
                });
                this.provider.on('disconnect', (error) => {
                    this.actions.resetState();
                    this.onError?.(error);
                });
                this.provider.on('chainChanged', (chainId) => {
                    this.actions.update({ chainId: parseChainId(chainId) });
                });
                this.provider.on('accountsChanged', (accounts) => {
                    this.actions.update({ accounts });
                });
            }
        }));
    }
    async connectEagerly() {
        const cancelActivation = this.actions.startActivation();
        try {
            await this.isomorphicInitialize();
            if (!this.provider)
                return cancelActivation();
            const accounts = (await this.provider.request({
                method: 'eth_accounts',
            }));
            if (!accounts.length)
                throw new Error('No accounts returned');
            const chainId = (await this.provider.request({
                method: 'eth_chainId',
            }));
            this.actions.update({
                chainId: parseChainId(chainId),
                accounts,
            });
        }
        catch (error) {
            cancelActivation();
            throw error;
        }
    }
    async activate(desiredChainIdOrChainParameters) {
        const desiredChainId = typeof desiredChainIdOrChainParameters === 'number'
            ? desiredChainIdOrChainParameters
            : desiredChainIdOrChainParameters?.chainId;
        const cancelActivation = this.actions.startActivation();
        try {
            await this.isomorphicInitialize();
            if (!this.provider)
                throw new Error('No AGW provider');
            await this.provider.request({ method: 'wallet_requestPermissions' });
            const accounts = (await this.provider.request({
                method: 'eth_accounts',
            }));
            if (!accounts.length)
                throw new Error('No accounts returned');
            const chainId = (await this.provider.request({
                method: 'eth_chainId',
            }));
            const receivedChainId = parseChainId(chainId);
            if (!desiredChainId || desiredChainId === receivedChainId)
                return this.actions.update({
                    chainId: receivedChainId,
                    accounts,
                });
            const desiredChain = VALID_CHAINS[desiredChainId];
            if (desiredChain) {
                const desiredChainIdHex = `0x${desiredChainId.toString(16)}`;
                await this.provider.request({
                    method: 'wallet_switchEthereumChain',
                    params: [{ chainId: desiredChainIdHex }],
                });
                await this.activate(desiredChainId);
            }
            else {
                throw new Error('Invalid chain');
            }
        }
        catch (error) {
            cancelActivation();
            throw error;
        }
    }
    async deactivate() {
        if (!this.provider)
            return;
        await this.provider.request({
            method: 'wallet_revokePermissions',
            params: [{ eth_accounts: {} }],
        });
        this.actions.resetState();
    }
}
exports.AbstractGlobalWallet = AbstractGlobalWallet;
//# sourceMappingURL=index.js.map