@paimaexample/wallets 0.3.117

package/esm/wallets/src/evm/injected.js

@@ -0,0 +1,322 @@
+import { AddressType } from "../../../utils/src/mod.js";
+import { optionToActive, } from "../IProvider.js";
+import { getWindow } from "../windows.js";
+import { utf8ToHex } from "web3-utils";
+import * as CHAINS from "viem/chains";
+const eip5953Providers = [];
+const windowObj = getWindow();
+if (windowObj && windowObj.addEventListener) {
+    windowObj.addEventListener("eip6963:announceProvider", (event) => {
+        eip5953Providers.push(event.detail);
+    });
+}
+if (windowObj && windowObj.dispatchEvent) {
+    windowObj?.dispatchEvent(new Event("eip6963:requestProvider"));
+}
+const CHAIN_NOT_ADDED_ERROR_CODE = 4902;
+export class EvmInjectedConnector {
+    provider;
+    static INSTANCE = undefined;
+    /**
+     * Wallets may inject themselves using multiple competing standards
+     * We have to track all of them (with duplicates) internally
+     * To make sure `connectNamed` calls properly find wallets no matter the name used
+     */
+    static getPossiblyDuplicateWalletOptions() {
+        const allWallets = [];
+        const windowObj = getWindow();
+        if (windowObj == null)
+            return [];
+        // 1) Add EIP6963 and prioritize it for deduplicating
+        {
+            const eip6963Options = eip5953Providers.map(({ info, provider }) => ({
+                metadata: {
+                    name: info.rdns,
+                    displayName: info.name,
+                    icon: info.icon,
+                },
+                api: () => Promise.resolve(provider),
+            }));
+            allWallets.push(...eip6963Options);
+        }
+        // 2) Add EIP5749
+        {
+            const eip5749Providers = windowObj.evmproviders ?? {};
+            const eip5749Options = Object.entries(eip5749Providers).map(([key, provider]) => ({
+                metadata: {
+                    name: key,
+                    displayName: provider.info.name,
+                    icon: provider.info.icon,
+                },
+                api: () => Promise.resolve(provider),
+            }));
+            allWallets.push(...eip5749Options);
+        }
+        // some wallets aggressively put themselves in the list of wallets the user has installed
+        // even if the user has never actually used these
+        // we put these wallets at the bottom of the priority
+        const aggressiveWallets = ["com.brave.wallet"];
+        allWallets.sort((a, b) => {
+            const aAggressive = aggressiveWallets.includes(a.metadata.name);
+            const bAggressive = aggressiveWallets.includes(b.metadata.name);
+            if (aAggressive && !bAggressive)
+                return 1;
+            if (bAggressive && !aAggressive)
+                return -1;
+            return 0;
+        });
+        return allWallets;
+    }
+    static getWalletOptions() {
+        const withDuplicates = EvmInjectedConnector
+            .getPossiblyDuplicateWalletOptions();
+        const seenNames = new Set();
+        const seenDisplayNames = new Set();
+        const result = [];
+        for (const option of withDuplicates) {
+            const lowerCaseName = option.metadata.displayName.toLowerCase();
+            if (seenNames.has(option.metadata.name))
+                continue;
+            if (seenDisplayNames.has(lowerCaseName))
+                continue;
+            seenNames.add(option.metadata.name);
+            seenDisplayNames.add(lowerCaseName);
+            result.push(option);
+        }
+        return result;
+    }
+    static instance() {
+        if (EvmInjectedConnector.INSTANCE == null) {
+            const newInstance = new EvmInjectedConnector();
+            EvmInjectedConnector.INSTANCE = newInstance;
+        }
+        return EvmInjectedConnector.INSTANCE;
+    }
+    connectSimple = async () => {
+        if (this.provider != null) {
+            return this.provider;
+        }
+        const options = EvmInjectedConnector.getWalletOptions();
+        if (options.length === 0) {
+            throw new Error(`No EVM wallet found`);
+        }
+        return await this.connectExternal(await optionToActive(options[0]));
+    };
+    connectExternal = async (conn) => {
+        if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+            return this.provider;
+        }
+        this.provider = await EvmInjectedProvider.init(conn);
+        // Update the selected Eth address if the user changes after logging in.
+        // warning: not supported by all wallets (ex: Flint)
+        const ethereum = getWindow().ethereum;
+        ethereum?.on("accountsChanged", (newAccounts) => {
+            const accounts = newAccounts;
+            if (!accounts || !accounts[0] || accounts[0] !== this.provider?.address) {
+                this.provider = undefined;
+            }
+        });
+        return this.provider;
+    };
+    connectNamed = async (name) => {
+        if (this.provider?.getConnection().metadata?.name === name) {
+            return this.provider;
+        }
+        // the eip6963 name for Metamask is io.metamask
+        // but we want to keep simply "metamask" working for backwards compatibility with older versions of Paima
+        const adjustedName = name.toLocaleLowerCase() === "metamask"
+            ? "io.metamask"
+            : name;
+        const provider = EvmInjectedConnector.getPossiblyDuplicateWalletOptions()
+            .find((entry) => entry.metadata.name === adjustedName);
+        if (provider == null) {
+            throw new Error(`EVM wallet ${name} not found`);
+        }
+        return await this.connectExternal(await optionToActive(provider));
+    };
+    getProvider = () => {
+        return this.provider;
+    };
+    getOrThrowProvider = () => {
+        if (this.provider == null) {
+            throw new Error(`EvmInjectedConnector not initialized yet`);
+        }
+        return this.provider;
+    };
+    isConnected = () => {
+        return this.provider != null;
+    };
+    switchChain = async (hexChainId, chain) => {
+        try {
+            // careful: not all wallets support switching chains
+            await this.provider?.getConnection().api.request({
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId: hexChainId }],
+            });
+            await this.verifyWalletChain(hexChainId);
+        }
+        catch (se) {
+            // deno-lint-ignore no-prototype-builtins
+            if (se.hasOwnProperty("code") && se.code === CHAIN_NOT_ADDED_ERROR_CODE) {
+                let targetChain = undefined;
+                Object.entries(CHAINS).forEach(([key, value]) => {
+                    const possibleChain = value;
+                    if (typeof possibleChain === "object" &&
+                        // deno-lint-ignore no-prototype-builtins
+                        possibleChain.hasOwnProperty("id") &&
+                        possibleChain.id === parseInt(hexChainId, 16)) {
+                        targetChain = possibleChain;
+                    }
+                });
+                if (chain) {
+                    targetChain = chain;
+                }
+                if (!targetChain) {
+                    throw new Error(`[switchChain] error: Chain not found`);
+                }
+                await this.addChain({
+                    chainId: hexChainId,
+                    chainName: targetChain.name,
+                    nativeCurrency: {
+                        name: targetChain.nativeCurrency.name,
+                        symbol: targetChain.nativeCurrency.symbol,
+                        decimals: targetChain.nativeCurrency.decimals,
+                    },
+                    rpcUrls: [targetChain.rpcUrls.default.http[0]],
+                    blockExplorerUrls: targetChain.blockExplorers?.default.url
+                        ? [targetChain.blockExplorers?.default.url]
+                        : undefined,
+                });
+            }
+            else {
+                throw new Error(`[switchChain] error: ${se?.message} ` + se?.code);
+            }
+        }
+    };
+    verifyWalletChain = async (chainId) => {
+        try {
+            const walletChain = await this.provider?.getConnection().api.request({
+                method: "eth_chainId",
+            });
+            return parseInt(walletChain, 16) === parseInt(chainId, 16);
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            throw new Error(`[verifyWalletChain] error: ${e?.message} ` + e?.code);
+        }
+    };
+    addChain = async (newChain) => {
+        try {
+            // careful: not all wallets support adding arbitrary chains
+            await this.provider?.getConnection().api.request({
+                method: "wallet_addEthereumChain",
+                params: [newChain],
+            });
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            throw new Error(`[addChain] error: ${e?.message} ` + e?.code);
+        }
+    };
+}
+export class EvmInjectedProvider {
+    conn;
+    address;
+    constructor(conn, address) {
+        this.conn = conn;
+        this.address = address;
+    }
+    static init = async (conn) => {
+        const accounts = (await conn.api.request({
+            method: "eth_requestAccounts",
+        }));
+        if (!accounts || accounts.length === 0) {
+            throw new Error("Unknown error while receiving EVM accounts");
+        }
+        return new EvmInjectedProvider(conn, accounts[0]);
+    };
+    getConnection = () => {
+        return this.conn;
+    };
+    getAddress = () => {
+        return {
+            type: AddressType.EVM,
+            address: this.address.toLowerCase(),
+        };
+    };
+    signMessage = async (message) => {
+        const hexMessage = utf8ToHex(message);
+        const signature = await this.conn.api.request({
+            method: "personal_sign",
+            params: [hexMessage, this.getAddress().address, ""],
+        });
+        if (typeof signature !== "string") {
+            console.log("[signMessageEth] invalid signature:", signature);
+            throw new Error(`[signMessageEth] Received signature of type ${typeof signature}`);
+        }
+        return signature;
+    };
+    verifyWalletChain = async () => {
+        try {
+            const walletChain = await this.conn.api.request({
+                method: "eth_chainId",
+            });
+            return true;
+            // TODO We have to move this to the top level
+            // return (
+            //   parseInt(walletChain as string, 16) ===
+            //   parseInt(this.gameInfo.gameChainId, 16)
+            // );
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            throw new Error(`[verifyWalletChain] error: ${e?.message} ` + e?.code);
+        }
+    };
+    addChain = async (newChain) => {
+        try {
+            // careful: not all wallets support adding arbitrary chains
+            await this.conn.api.request({
+                method: "wallet_addEthereumChain",
+                params: [newChain],
+            });
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            throw new Error(`[addChain] error: ${e?.message} ` + e?.code);
+        }
+    };
+    switchChain = async (hexChainId) => {
+        try {
+            // careful: not all wallets support switching chains
+            await this.conn.api.request({
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId: hexChainId }],
+            });
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            throw new Error(`[switchChain] error: ${e?.message} ` + e?.code);
+        }
+    };
+    sendTransaction = async (tx) => {
+        await this.verifyWalletChain();
+        try {
+            const hash = await this.conn.api.request({
+                method: "eth_sendTransaction",
+                params: [tx],
+            });
+            if (typeof hash !== "string") {
+                console.log("[sendTransaction] invalid signature:", hash);
+                throw new Error(`[sendTransaction] Received "hash" of type ${typeof hash}`);
+            }
+            return {
+                txHash: hash,
+            };
+        }
+        catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            throw new Error(`[sendTransaction] error: ${e?.message} ` + e?.code);
+        }
+    };
+}

package/esm/wallets/src/evm/types.d.ts

@@ -0,0 +1,3 @@
+export type EvmAddress = string;
+export declare const DEFAULT_GAS_LIMIT = 100000;
+//# sourceMappingURL=types.d.ts.map

package/esm/wallets/src/evm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/wallets/src/evm/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAChC,eAAO,MAAM,iBAAiB,SAAS,CAAC"}

package/esm/wallets/src/evm/types.js

@@ -0,0 +1 @@
+export const DEFAULT_GAS_LIMIT = 100000;

package/esm/wallets/src/evm/wrapper-ethers.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from "../../../utils/src/mod.js";
+import type { IProvider } from "../IProvider.js";
+import type { WalletMode, ApiForMode } from "../utils.js";
+import type { LoginInfoMap } from "../wallet-modes.js";
+export declare function ethersLoginWrapper(loginInfo: LoginInfoMap[WalletMode.EvmEthers]): Promise<Result<IProvider<ApiForMode<WalletMode.EvmEthers>>>>;
+//# sourceMappingURL=wrapper-ethers.d.ts.map

package/esm/wallets/src/evm/wrapper-ethers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper-ethers.d.ts","sourceRoot":"","sources":["../../../../src/wallets/src/evm/wrapper-ethers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAyBvD,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,YAAY,CAAC,UAAU,CAAC,SAAS,CAAC,GAC5C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAkB9D"}

package/esm/wallets/src/evm/wrapper-ethers.js

@@ -0,0 +1,38 @@
+import { EthersConnector } from "./ethers.js";
+async function connectWallet(loginInfo) {
+    const name = loginInfo.connection.metadata.name;
+    try {
+        console.log(`ethersLoginWrapper: Attempting to log into ${name}`);
+        const provider = await EthersConnector.instance().connectExternal(loginInfo.connection.api);
+        return {
+            success: true,
+            result: provider,
+        };
+    }
+    catch (err) {
+        console.log(`ethersLoginWrapper: Error while logging into wallet name}`);
+        return {
+            success: false,
+            errorMessage: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function ethersLoginWrapper(loginInfo) {
+    const loginResult = await connectWallet(loginInfo);
+    if (loginResult.success === false) {
+        return loginResult;
+    }
+    try {
+        // TODO Move this to the top level
+        // await updateFee();
+    }
+    catch (err) {
+        // errorFxn(PaimaMiddlewareErrorCode.ERROR_UPDATING_FEE, err);
+        // The fee has a default value, so this is not fatal and we can continue.
+        // If the fee has increased beyond the default value, posting won't work.
+    }
+    return {
+        success: true,
+        result: loginResult.result,
+    };
+}

package/esm/wallets/src/evm/wrapper-injected.d.ts

@@ -0,0 +1,7 @@
+import type { Result } from "../../../utils/src/mod.js";
+import type { IProvider } from "../IProvider.js";
+import type { ApiForMode, WalletMode } from "../utils.js";
+import { type LoginInfoMap } from "../wallet-modes.js";
+export declare function checkEthWalletStatus(): Promise<Result<string>>;
+export declare function evmLoginWrapper(loginInfo: LoginInfoMap[WalletMode.EvmInjected]): Promise<Result<IProvider<ApiForMode<WalletMode.EvmInjected>>>>;
+//# sourceMappingURL=wrapper-injected.d.ts.map

package/esm/wallets/src/evm/wrapper-injected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper-injected.d.ts","sourceRoot":"","sources":["../../../../src/wallets/src/evm/wrapper-injected.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AA4BxE,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAmBpE;AAED,wBAAsB,eAAe,CACnC,SAAS,EAAE,YAAY,CAAC,UAAU,CAAC,WAAW,CAAC,GAC9C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAgDhE"}

package/esm/wallets/src/evm/wrapper-injected.js

@@ -0,0 +1,80 @@
+import { connectInjected } from "../wallet-modes.js";
+import { EvmInjectedConnector } from "./injected.js";
+async function switchChain(chain) {
+    if (!chain) {
+        // We can't switch to a chain if we don't know what chain to switch to.
+        return false;
+    }
+    const hexChainId = "0x" + chain.id.toString(16);
+    await EvmInjectedConnector.instance().switchChain(hexChainId, chain);
+    return await verifyWalletChain(chain);
+}
+async function verifyWalletChain(chain) {
+    if (!chain) {
+        return false;
+    }
+    const hexChainId = "0x" + chain.id.toString(16);
+    return await EvmInjectedConnector.instance().verifyWalletChain(hexChainId);
+}
+export async function checkEthWalletStatus() {
+    // const errorFxn = buildEndpointErrorFxn('checkEthWalletStatus');
+    // if (!hasLogin(WalletMode.EvmInjected)) {
+    //   return { success: true, message: '' };
+    // }
+    if (EvmInjectedConnector.instance().getProvider() === null) {
+        return { success: false, errorMessage: "No address selected" };
+    }
+    try {
+        if (!(await verifyWalletChain(undefined))) {
+            return { success: false, errorMessage: "EVM_WRONG_CHAIN" };
+        }
+    }
+    catch (err) {
+        return { success: false, errorMessage: "EVM_CHAIN_VERIFICATION" };
+    }
+    return { success: true, result: "OK" };
+}
+export async function evmLoginWrapper(loginInfo) {
+    // const errorFxn = buildEndpointErrorFxn('evmLoginWrapper');
+    // const evmConfig = await GlobalConfig.mainEvmConfig();
+    // if (evmConfig == null) {
+    //   return errorFxn(
+    //     PaimaMiddlewareErrorCode.EVM_LOGIN,
+    //     new Error(`No EVM network found in configuration`)
+    //   );
+    // }
+    // const [_, config] = evmConfig;
+    // const gameInfo = {
+    //   gameName: getGameName(),
+    //   gameChainId: '0x' + config.chainId.toString(16),
+    // };
+    const loginResult = await connectInjected("evmLoginWrapper", loginInfo, EvmInjectedConnector.instance());
+    if (loginResult.success === false) {
+        return loginResult;
+    }
+    try {
+        // TODO Move this to the top level
+        // await updateFee();
+    }
+    catch (err) {
+        // errorFxn(PaimaMiddlewareErrorCode.ERROR_UPDATING_FEE, err);
+        // The fee has a default value, so this is not fatal and we can continue.
+        // If the fee has increased beyond the default value, posting won't work.
+    }
+    try {
+        if (loginInfo.checkChainId !== false) {
+            if (!(await verifyWalletChain(loginInfo.chain))) {
+                if (!(await switchChain(loginInfo.chain))) {
+                    return { success: false, errorMessage: "EVM_CHAIN_SWITCH" };
+                }
+            }
+        }
+    }
+    catch (err) {
+        return { success: false, errorMessage: "EVM_CHAIN_SWITCH" };
+    }
+    return {
+        success: true,
+        result: loginResult.result,
+    };
+}

package/esm/wallets/src/midnight/midnight.d.ts

@@ -0,0 +1,26 @@
+import { type MidnightAddress } from "../../../utils/src/mod.js";
+import { type IInjectedConnector, type ActiveConnection, type IProvider, type AddressAndType, type UserSignature, type IConnector, type ConnectionOption } from "../IProvider.js";
+export type MidnightApi = any;
+export declare class MidnightConnector implements IConnector<MidnightApi>, IInjectedConnector<MidnightApi> {
+    private provider;
+    private static INSTANCE;
+    static getWalletOptions(): ConnectionOption<MidnightApi>[];
+    static instance(): MidnightConnector;
+    getOrThrowProvider: () => MidnightProvider;
+    getProvider: () => undefined | MidnightProvider;
+    isConnected(): boolean;
+    connectSimple: () => Promise<MidnightProvider>;
+    connectNamed: (name: string) => Promise<MidnightProvider>;
+    connectExternal: (conn: ActiveConnection<MidnightApi>) => Promise<MidnightProvider>;
+}
+export declare class MidnightProvider implements IProvider<MidnightApi> {
+    private readonly conn;
+    readonly address: MidnightAddress;
+    constructor(conn: ActiveConnection<MidnightApi>, address: MidnightAddress);
+    static init: (conn: ActiveConnection<MidnightApi>) => Promise<MidnightProvider>;
+    getConnection(): ActiveConnection<MidnightApi>;
+    signMessage: (message: string) => Promise<UserSignature>;
+    getAddress(): AddressAndType;
+    static fetchAddress: (conn: ActiveConnection<MidnightApi>) => Promise<string>;
+}
+//# sourceMappingURL=midnight.d.ts.map

package/esm/wallets/src/midnight/midnight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midnight.d.ts","sourceRoot":"","sources":["../../../../src/wallets/src/midnight/midnight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,gBAAgB,EAEtB,MAAM,iBAAiB,CAAC;AAIzB,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC;AAG9B,qBAAa,iBAAkB,YAAW,UAAU,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAC,WAAW,CAAC;IAChG,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA4C;IAEnE,MAAM,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,WAAW,CAAC,EAAE;IAoB1D,MAAM,CAAC,QAAQ,IAAI,iBAAiB;IAQpC,kBAAkB,QAAO,gBAAgB,CAKvC;IAEF,WAAW,QAAO,SAAS,GAAG,gBAAgB,CAE5C;IAEF,WAAW,IAAI,OAAO;IAItB,aAAa,QAAa,OAAO,CAAC,gBAAgB,CAAC,CAUjD;IAEF,YAAY,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,gBAAgB,CAAC,CAW7D;IAED,eAAe,GAAU,MAAM,gBAAgB,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC,gBAAgB,CAAC,CAMvF;CAEF;AAGD,qBAAa,gBAAiB,YAAW,SAAS,CAAC,WAAW,CAAC;IAE3D,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,QAAQ,CAAC,OAAO,EAAE,eAAe;gBADhB,IAAI,EAAE,gBAAgB,CAAC,WAAW,CAAC,EAC3C,OAAO,EAAE,eAAe;IAGnC,MAAM,CAAC,IAAI,GACT,MAAM,gBAAgB,CAAC,WAAW,CAAC,KAClC,OAAO,CAAC,gBAAgB,CAAC,CAO1B;IAEF,aAAa,IAAI,gBAAgB,CAAC,WAAW,CAAC;IAI9C,WAAW,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,aAAa,CAAC,CAG3D;IAEF,UAAU,IAAI,cAAc;IAO5B,MAAM,CAAC,YAAY,GAAU,MAAM,gBAAgB,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC,MAAM,CAAC,CAShF;CACH"}

package/esm/wallets/src/midnight/midnight.js

@@ -0,0 +1,112 @@
+import { AddressType } from "../../../utils/src/mod.js";
+import { optionToActive, } from "../IProvider.js";
+import { getWindow } from "../windows.js";
+// TODO Implement this class
+export class MidnightConnector {
+    provider;
+    static INSTANCE = undefined;
+    static getWalletOptions() {
+        const midnightApi = getWindow()?.midnight;
+        if (midnightApi == null)
+            return [];
+        const options = Object.entries(midnightApi).reduce((options, [key, info]) => {
+            if (info.name != null && info.enable != null && info.name === 'lace') {
+                options.push({
+                    metadata: {
+                        name: key,
+                        displayName: info.name,
+                        icon: 'icon' in info ? info.icon : undefined,
+                    },
+                    api: info.enable,
+                });
+            }
+            return options;
+        }, []);
+        return options;
+    }
+    static instance() {
+        if (MidnightConnector.INSTANCE == null) {
+            const newInstance = new MidnightConnector();
+            MidnightConnector.INSTANCE = newInstance;
+        }
+        return MidnightConnector.INSTANCE;
+    }
+    getOrThrowProvider = () => {
+        if (this.provider == null) {
+            throw new Error(`MidnightConnector provider isn't initialized yet`);
+        }
+        return this.provider;
+    };
+    getProvider = () => {
+        return this.provider;
+    };
+    isConnected() {
+        return this.provider != null;
+    }
+    connectSimple = async () => {
+        if (this.provider != null) {
+            return this.provider;
+        }
+        const options = MidnightConnector.getWalletOptions();
+        if (options.length === 0) {
+            throw new Error(`No Midnight wallet found`);
+        }
+        return await this.connectExternal(await optionToActive(options[0]));
+    };
+    connectNamed = async (name) => {
+        if (this.provider?.getConnection().metadata?.name === name) {
+            return this.provider;
+        }
+        const provider = MidnightConnector.getWalletOptions().find(entry => entry.metadata.name === name);
+        if (provider == null) {
+            throw new Error(`Midnight wallet ${name} not found`);
+        }
+        return await this.connectExternal(await optionToActive(provider));
+    };
+    connectExternal = async (conn) => {
+        if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+            return this.provider;
+        }
+        this.provider = await MidnightProvider.init(conn);
+        return this.provider;
+    };
+}
+// TODO Implement this class
+export class MidnightProvider {
+    conn;
+    address;
+    constructor(conn, address) {
+        this.conn = conn;
+        this.address = address;
+    }
+    static init = async (conn) => {
+        const hexAddress = await MidnightProvider.fetchAddress(conn);
+        // const prefix = pickBech32Prefix(hexAddress);
+        // const words = bech32.toWords(hexStringToUint8Array(hexAddress));
+        // const userAddress = bech32.encode(prefix, words, 200);
+        return new MidnightProvider(conn, hexAddress);
+    };
+    getConnection() {
+        return this.conn;
+    }
+    signMessage = async (message) => {
+        console.log('NYI LACE: MidnightProvider.signMessage', message);
+        return message; // this.conn.api.signMessage(message);
+    };
+    getAddress() {
+        return {
+            type: AddressType.MIDNIGHT,
+            address: this.address,
+        };
+    }
+    static fetchAddress = async (conn) => {
+        const state = await conn.api.state();
+        // address : "mn_shield-addr_undeployed1k7dst6qphntqmypwa4mhyltk794wx4lta07kherlc9y6clu5swssxqr9xe4z7txy8rscldhec7nmm47ujccf7syky0wz86jwahhkfd3mvq9wu8qx"
+        // addressLegacy : "b79b05e801bcd60d902eed77727d76f16ae357ebebfd6be47fc149ac7f9483a1|030065366a2f2cc438e18fb6f9c7a7bdd7dc96309f409623dc23ea4eedef64b63b60"
+        // coinPublicKey : "mn_shield-cpk_undeployed1k7dst6qphntqmypwa4mhyltk794wx4lta07kherlc9y6clu5swsspxas0m"
+        // coinPublicKeyLegacy : "b79b05e801bcd60d902eed77727d76f16ae357ebebfd6be47fc149ac7f9483a1"
+        // encryptionPublicKey : "mn_shield-epk_undeployed1qvqx2dn29ukvgw8p37m0n3a8hhtae93snaqfvg7uy04yam00vjmrkcqtdla9r"
+        // encryptionPublicKeyLegacy : "030065366a2f2cc438e18fb6f9c7a7bdd7dc96309f409623dc23ea4eedef64b63b60"
+        return state.address;
+    };
+}

package/esm/wallets/src/midnight/wrapper.d.ts

@@ -0,0 +1,7 @@
+import type { Result } from "../../../utils/src/mod.js";
+import type { IProvider } from "../IProvider.js";
+import type { WalletMode, ApiForMode } from "../utils.js";
+import { type LoginInfoMap } from "../wallet-modes.js";
+export declare function checkMidnightWalletStatus(): Promise<Result<string>>;
+export declare function midnightLoginWrapper(loginInfo: LoginInfoMap[WalletMode.Midnight]): Promise<Result<IProvider<ApiForMode<WalletMode.Midnight>>>>;
+//# sourceMappingURL=wrapper.d.ts.map

package/esm/wallets/src/midnight/wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../../../src/wallets/src/midnight/wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,KAAK,YAAY,EAAmB,MAAM,oBAAoB,CAAC;AAGxE,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAUzE;AAED,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,GAC3C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAa7D"}

package/esm/wallets/src/midnight/wrapper.js

@@ -0,0 +1,22 @@
+import { connectInjected } from "../wallet-modes.js";
+import { MidnightConnector } from "./midnight.js";
+export async function checkMidnightWalletStatus() {
+    const provider = MidnightConnector.instance().getProvider();
+    if (provider == null) {
+        return {
+            success: false,
+            errorMessage: "No Midnight wallet found",
+        };
+    }
+    return { success: true, result: "OK" };
+}
+export async function midnightLoginWrapper(loginInfo) {
+    const loginResult = await connectInjected("midnightLoginWrapper", loginInfo, MidnightConnector.instance());
+    if (loginResult.success === false) {
+        return loginResult;
+    }
+    return {
+        success: true,
+        result: loginResult.result,
+    };
+}