@intuweb3/sdk/services/web3/utils.js

INTU SDK - Modern blockchain interaction toolkit

import { ethers } from "ethers";
import { getVaultContract } from "./helper/index.js";
import { createViemClient, getVaultContractViem } from "./helper/index.js";
import { gql, request } from "graphql-request";
import { getGraphEndpoint, getBackupGraphEndpoint, } from "../../tools/constants.js";
import { getQuery } from "../../tools/graph.js";
import { getBestProvider } from "../../utils/reliable-provider.js";
export async function fetchSubgraphData(chainId, query) {
    const primaryEndpoint = getGraphEndpoint(chainId);
    const goldskyBackup = getBackupGraphEndpoint(chainId);
    try {
        const response = await request(primaryEndpoint, query);
        if (response && Object.keys(response).length > 0) {
            const result = response.data || response;
            return result;
        }
        const goldskyQuery = await getGoldskyQuery(chainId, query);
        const backupResponse = await request(goldskyBackup, goldskyQuery);
        return backupResponse.data || backupResponse;
    }
    catch (err) {
        console.debug(`❌ [FETCH_SUBGRAPH] Primary Hyperindex error:`, err?.message || err);
        try {
            const goldskyQuery = await getGoldskyQuery(chainId, query);
            const backupResponse = await request(goldskyBackup, goldskyQuery);
            console.debug(`✅ [FETCH_SUBGRAPH] Goldsky backup request successful`);
            return backupResponse;
        }
        catch (backupErr) {
            console.debug(`❌ [FETCH_SUBGRAPH] Goldsky backup error:`, backupErr?.message || backupErr);
            console.debug(`❌ [FETCH_SUBGRAPH] Both data sources failed for chainId ${chainId}`);
            return null;
        }
    }
}
async function getGoldskyQuery(chainId, hyperindexQuery) {
    const { getQuery } = await import("../../tools/graph.js");
    const vaultAddressMatch = hyperindexQuery.match(/vaultAddress.*?_ilike.*?"([^"]+)"/);
    const txIdMatch = hyperindexQuery.match(/txId.*?_eq.*?"([^"]+)"/);
    const userAddressMatch = hyperindexQuery.match(/proposedAddresses.*?_contains.*?\["([^"]+)"\]/);
    if (vaultAddressMatch && txIdMatch) {
        const vaultAddress = vaultAddressMatch[1];
        const txId = txIdMatch[1];
        return getQuery("getTransactionById", chainId, { vaultAddress, txId }, "goldsky");
    }
    else if (vaultAddressMatch) {
        const vaultAddress = vaultAddressMatch[1];
        return getQuery("getVaultTransactions", chainId, { vaultAddress }, "goldsky");
    }
    else if (userAddressMatch) {
        const userAddress = userAddressMatch[1];
        return getQuery("getVaultCreateds", chainId, { userAddress }, "goldsky");
    }
    console.warn("⚠️ [GOLDSKY_QUERY] Could not convert query, using original");
    return hyperindexQuery;
}
export async function getUserIndex(vaultAddress, userAddress, provider) {
    const client = await createViemClient(provider);
    const vaultContract = await getVaultContractViem(vaultAddress, client);
    const vaultInfos = await vaultContract.read.vaultInfos();
    const users = vaultInfos.users;
    const index = users.findIndex((address) => address.toLowerCase() === userAddress.toLowerCase());
    if (index < 0) {
        const userToAdd = await vaultContract.getUserToAdd();
        const matchedUserIndex = userToAdd.findIndex((user) => user.toLowerCase() === userAddress.toLowerCase());
        if (matchedUserIndex >= 0) {
            return users.length + matchedUserIndex;
        }
        else {
            throw new Error(`the given userAddress: ${userAddress} is not found in the user list of the vault address: ${vaultAddress}`);
        }
    }
    return index;
}
export async function getUserPreRegisterInfos(vaultAddress, userAddress, provider) {
    if (provider.isMetaMask || provider.isRainbow) {
        provider = new ethers.providers.Web3Provider(window.ethereum);
    }
    const chainId = (await provider.getNetwork()).chainId;
    const queryString = getQuery("vaultUserPreRegister", chainId, {
        vaultAddress,
        userAddress,
    });
    const query = gql `
    ${queryString}
  `;
    const data = await fetchSubgraphData(chainId, query);
    if (!data) {
        return {
            user: userAddress,
            registered: false,
            parisEncKey: "",
            megaPublicKey: "",
            encMegaSecretKey: "",
            dbKey: "",
        };
    }
    const resultKey = chainId === 421614 || chainId === 42161
        ? "VaultUserPreRegister"
        : "VaultUserPreRegister";
    if (data[resultKey] && data[resultKey].length > 0) {
        const userPreRegister = data[resultKey].find((entry) => entry.user.toLowerCase() === userAddress.toLowerCase());
        if (userPreRegister) {
            return {
                user: userPreRegister.user,
                registered: true,
                parisEncKey: userPreRegister.parisEncKey,
                megaPublicKey: userPreRegister.megaPublicKey,
                encMegaSecretKey: userPreRegister.encSharedKey,
                dbKey: userPreRegister.dbKey,
            };
        }
    }
    return {
        user: userAddress,
        registered: false,
        parisEncKey: "",
        megaPublicKey: "",
        encMegaSecretKey: "",
        dbKey: "",
    };
}
export async function getUserRegistrationAllInfos(vaultAddress, provider) {
    const client = await createViemClient(provider);
    const vaultContract = await getVaultContractViem(vaultAddress, client);
    const [vaultInfo] = await Promise.all([
        vaultContract.read.vaultInfos(),
        client.getBlockNumber(),
    ]);
    let users = vaultInfo.users;
    const userRegistrations = new Array(users.length).fill(null);
    const chainId = (await provider.getNetwork()).chainId;
    const queryString = getQuery("vaultUserRegisteredAll", chainId, {
        vaultAddress,
    });
    const query = gql `
    ${queryString}
  `;
    const data = await fetchSubgraphData(chainId, query);
    const resultKey = "VaultUserRegisteredAll";
    if (data && data[resultKey]) {
        data[resultKey].forEach((registration) => {
            const userIndex = users.findIndex((user) => user.toLowerCase() === registration.user.toLowerCase());
            if (userIndex !== -1) {
                userRegistrations[userIndex] = {
                    user: registration.user,
                    registered: true,
                    step1Dealings: registration.step1Dealings || "",
                    pedersenOpeningKey: registration.openingKey || "",
                    pedersenOpeningKappa: registration.openingKappa || "",
                    pedersenOpeningLambda: registration.openingLambda || "",
                    simpleDealingKey: registration.simpleDealingKey || "",
                    simpleDealingKappa: registration.simpleDealingKappa || "",
                    pedersenTranscriptKey: registration.transcriptKey || "",
                    pedersenTranscriptKappa: registration.transcriptKappa || "",
                    pedersenTranscriptLambda: registration.transcriptLambda || "",
                    step3Crypto: registration.step3Crypto || "",
                };
            }
        });
    }
    return userRegistrations;
}
export async function getPreRegisterInfos(vaultAddress, provider) {
    const client = await createViemClient(provider);
    const vaultContract = await getVaultContractViem(vaultAddress, client);
    const [vaultInfos, userToAdd = [], userToRemove = []] = await Promise.all([
        vaultContract.read.vaultInfos(),
        vaultContract.read.getUserToAdd().catch(() => []),
        vaultContract.read.getUserToRemove().catch(() => []),
    ]);
    let users = vaultInfos.users;
    if (userToAdd.length > 0) {
        users = [...users, ...userToAdd];
    }
    const parisEncKeyArray = new Array(users.length).fill("");
    const megaPublicKeyArray = new Array(users.length).fill("");
    const encMegaSecretKeyArray = new Array(users.length).fill("");
    const dbPublicKeyArray = new Array(users.length).fill("");
    const chainId = (await provider.getNetwork()).chainId;
    const queryString = getQuery("vaultUserPreRegister", chainId, {
        vaultAddress,
    });
    const query = gql `
    ${queryString}
  `;
    const data = await fetchSubgraphData(chainId, query);
    const resultKey = chainId === 421614 || chainId === 42161
        ? "VaultUserPreRegister"
        : "VaultUserPreRegister";
    if (data && data[resultKey]) {
        data[resultKey].forEach((preRegister) => {
            const userIndex = users.findIndex((user) => user.toLowerCase() === preRegister.user.toLowerCase());
            if (userIndex !== -1) {
                parisEncKeyArray[userIndex] = preRegister.parisEncKey || "";
                megaPublicKeyArray[userIndex] = preRegister.megaPublicKey || "";
                encMegaSecretKeyArray[userIndex] = preRegister.encSharedKey || "";
                dbPublicKeyArray[userIndex] = preRegister.dbKey || "";
            }
        });
    }
    return {
        parisEncKeyArray,
        megaPublicKeyArray,
        encMegaSecretKeyArray,
        dbPublicKeyArray,
    };
}
export async function getRegistrationStep3InfosDB(vaultAddress, provider) {
    const client = await createViemClient(provider);
    const vaultContract = await getVaultContractViem(vaultAddress, client);
    const { users } = await vaultContract.read.vaultInfos();
    const simpleKeyArray = [];
    const simpleKappaArray = [];
    const dealingKeyXLambdaArray = [];
    const dealingKappaXLambdaArray = [];
    const chainId = (await provider.getNetwork()).chainId;
    const queryString = getQuery("vaultUserRegisteredAll", chainId, {
        vaultAddress,
    });
    const query = gql `
    ${queryString}
  `;
    const data = await fetchSubgraphData(chainId, query);
    const resultKey = "VaultUserRegisteredAll";
    if (data && data[resultKey]) {
        data[resultKey].forEach((registration) => {
            const userIndex = users.findIndex((user) => user.toLowerCase() === registration.user.toLowerCase());
            if (userIndex !== -1) {
                const step3Result = JSON.parse(atob(registration.step3Crypto));
                simpleKeyArray[userIndex] = step3Result[0];
                simpleKappaArray[userIndex] = step3Result[1];
                dealingKeyXLambdaArray[userIndex] = step3Result[2];
                dealingKappaXLambdaArray[userIndex] = step3Result[3];
            }
        });
    }
    return {
        simpleKeyArray,
        simpleKappaArray,
        dealingKeyXLambdaArray,
        dealingKappaXLambdaArray,
    };
}
export async function getRegistrationReshareStep3InfosDB(vaultAddress, provider) {
    const client = await createViemClient(provider);
    const vaultContract = await getVaultContractViem(vaultAddress, client);
    const { users } = await vaultContract.read.vaultInfos();
    const pedersenDealingsLambdaReshareArray = [];
    const dealingsKeyXLambdaReshareArray = [];
    const dealingsKappaXLambdaReshareArray = [];
    const chainId = (await provider.getNetwork()).chainId;
    const queryString = getQuery("getUserReSharingStep1Info", chainId, {
        vaultAddress,
    });
    const query = gql `
    ${queryString}
  `;
    const data = await fetchSubgraphData(chainId, query);
    const resultKey = "UserReSharingStep1Info";
    if (data && data[resultKey]) {
        data[resultKey].forEach((registration) => {
            const userIndex = users.findIndex((user) => user.toLowerCase() === registration.user.toLowerCase());
            if (userIndex !== -1) {
                const step3Result = JSON.parse(atob(registration[userIndex].step3Crypto));
                const step1Result = JSON.parse(atob(registration[userIndex].step1Dealings));
                pedersenDealingsLambdaReshareArray[userIndex] = step1Result[2];
                dealingsKeyXLambdaReshareArray[userIndex] = step3Result[2];
                dealingsKappaXLambdaReshareArray[userIndex] = step3Result[3];
            }
        });
    }
    return {
        pedersenDealingsLambdaReshareArray,
        dealingsKeyXLambdaReshareArray,
        dealingsKappaXLambdaReshareArray,
    };
}
export async function getUtilsParams(vaultAddress, userAddress, provider) {
    const client = await createViemClient(provider);
    const vaultContract = await getVaultContractViem(vaultAddress, client);
    const { transactionThreshold, seed } = await vaultContract.read.vaultInfos();
    const index = await getUserIndex(vaultAddress, userAddress, provider);
    let megaPublicKeyArray = [];
    let encMegaSecretKey = [];
    let dbKeyArray = [];
    let result = await getPreRegisterInfos(vaultAddress, provider);
    megaPublicKeyArray = result.megaPublicKeyArray;
    encMegaSecretKey = result.encMegaSecretKeyArray;
    dbKeyArray = result.dbPublicKeyArray;
    return {
        seed: seed,
        threshold: Number(transactionThreshold),
        index: index,
        megaPkArray: megaPublicKeyArray,
        encMegaSecretKey: encMegaSecretKey,
        dbKeyArray: dbKeyArray,
    };
}
export async function getUserSignature(vaultAddress, signer) {
    const chainId = (await signer.provider.getNetwork()).chainId;
    const provider = await getBestProvider(chainId, signer);
    const vaultContract = await getVaultContract(vaultAddress, provider);
    let { encryptionMessage } = await vaultContract.vaultInfos();
    const domain = {};
    const types = {
        SigningVaultEncryptionMessage: [
            { name: "to use your secret share", type: "string" },
        ],
    };
    const value = {
        "to use your secret share": encryptionMessage,
    };
    const finalSigner = signer;
    let result = await finalSigner._signTypedData(domain, types, value);
    return result;
}
//# sourceMappingURL=utils.js.map