@alchemy/aa-core/dist/esm/utils/index.js

viem based SDK that enables interactions with ERC-4337 Smart Accounts. ABIs are based off the definitions generated in @account-abstraction/contracts

import { toHex } from "viem";
import * as chains from "viem/chains";
import * as alchemyChains from "../chains/index.js";
export const AlchemyChainMap = new Map(Object.values(alchemyChains).map((c) => [c.id, c]));
export const getChain = (chainId) => {
    for (const chain of Object.values(chains)) {
        if (chain.id === chainId) {
            return AlchemyChainMap.get(chain.id) ?? chain;
        }
    }
    throw new Error("could not find chain");
};
export const asyncPipe = (...fns) => async (s, o, f) => {
    let result = s;
    for (const fn of fns) {
        result = await fn(result, o, f);
    }
    return result;
};
export async function resolveProperties(object) {
    const promises = Object.keys(object).map((key) => {
        const value = object[key];
        return Promise.resolve(value).then((v) => ({ key: key, value: v }));
    });
    const results = await Promise.all(promises);
    return filterUndefined(results.reduce((accum, curr) => {
        accum[curr.key] = curr.value;
        return accum;
    }, {}));
}
export function deepHexlify(obj) {
    if (typeof obj === "function") {
        return undefined;
    }
    if (obj == null || typeof obj === "string" || typeof obj === "boolean") {
        return obj;
    }
    else if (typeof obj === "bigint") {
        return toHex(obj);
    }
    else if (obj._isBigNumber != null || typeof obj !== "object") {
        return toHex(obj).replace(/^0x0/, "0x");
    }
    if (Array.isArray(obj)) {
        return obj.map((member) => deepHexlify(member));
    }
    return Object.keys(obj).reduce((set, key) => ({
        ...set,
        [key]: deepHexlify(obj[key]),
    }), {});
}
export function defineReadOnly(object, key, value) {
    Object.defineProperty(object, key, {
        enumerable: true,
        value: value,
        writable: false,
    });
}
export function filterUndefined(obj) {
    for (const key in obj) {
        if (obj[key] == null) {
            delete obj[key];
        }
    }
    return obj;
}
export function pick(obj, keys) {
    return Object.keys(obj)
        .filter((k) => keys.includes(k))
        .reduce((res, k) => Object.assign(res, { [k]: obj[k] }), {});
}
export const allEqual = (...params) => {
    if (params.length === 0) {
        throw new Error("no values passed in");
    }
    return params.every((v) => v === params[0]);
};
export const conditionalReturn = (condition, value) => condition.then((t) => (t ? value() : undefined));
export const toRecord = (array, selector, fn) => array.reduce((acc, item) => {
    acc[item[selector]] = fn(item);
    return acc;
}, {});
export * from "./bigint.js";
export * from "./bytes.js";
export * from "./defaults.js";
export * from "./schema.js";
export * from "./userop.js";
//# sourceMappingURL=index.js.map