@orb-labs/orby-core 0.0.14 → 0.0.16

package/dist/cjs/actions/operation.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationActions = void 0;
+const action_helpers_js_1 = require("../utils/action_helpers.js");
+const currency_amount_js_1 = require("../entities/financial/currency_amount.js");
+const enums_js_1 = require("../enums.js");
+const library_request_js_1 = require("../entities/library_request.js");
+const utils_js_1 = require("../utils/utils.js");
+const account_js_1 = require("../entities/account.js");
+// from here: https://stackoverflow.com/questions/65152373/typescript-serialize-bigint-in-json
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};
+class OperationActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async getOperationsToExecuteTransaction(accountClusterId, to, data, value, gasToken) {
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToExecuteTransaction", [
+            {
+                accountClusterId,
+                to,
+                data,
+                value,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    async getOperationsToSignTypedData(accountClusterId, data, gasToken) {
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToSignTypedData", [
+            {
+                accountClusterId,
+                data,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    async getOperationsToCancelTransaction(accountClusterId, operationSetId) {
+        const operationSet = await this.sendRequest("orby_getOperationsToCancelTransaction", [
+            {
+                accountClusterId,
+                operationSetId,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    async isTransactionPreconditionSatisfied(accountClusterId, to, data, value) {
+        const { satisfied } = await this.sendRequest("orby_isTransactionPreconditionSatisfied", [
+            {
+                accountClusterId,
+                to,
+                data,
+                value,
+            },
+        ]);
+        return satisfied;
+    }
+    async isTypedDataPreconditionSatisfied(accountClusterId, data) {
+        const { satisfied, code, message } = await this.sendRequest("orby_isTypedDataPreconditionSatisfied", [
+            {
+                accountClusterId,
+                data,
+            },
+        ]);
+        if (code && message) {
+            console.error("[isTypedDataPreconditionSatisfied]", code, message);
+            return undefined;
+        }
+        return satisfied;
+    }
+    async sendSignedOperations(accountClusterId, signedOperations) {
+        const { operationSetId, operationResponses, code, message } = await this.sendRequest("orby_sendSignedOperations", [
+            {
+                accountClusterId,
+                signedOperations,
+            },
+        ]);
+        if (code && message) {
+            console.error("[sendSignedOperations]", code, message);
+            return undefined;
+        }
+        return {
+            operationSetId,
+            operationResponses: (0, action_helpers_js_1.extractOperationStatuses)(operationResponses),
+        };
+    }
+    async getOperationStatuses(operationIds) {
+        const { operationStatuses } = await this.sendRequest("orby_getOperationStatuses", [{ operationIds }]);
+        return (0, action_helpers_js_1.extractOperationStatuses)(operationStatuses);
+    }
+    async estimateFiatCostToExecuteTransaction(to, data, value) {
+        const { estimatedCost, code, message } = await this.sendRequest("orby_estimateFiatCostToExecuteTransaction", [
+            {
+                to,
+                data,
+                value,
+            },
+        ]);
+        if (code && message) {
+            console.error("[estimateFiatCostToExecuteTransaction]", code, message);
+            return undefined;
+        }
+        return currency_amount_js_1.CurrencyAmount.toCurrencyAmount(estimatedCost);
+    }
+    async estimateFiatCostToSignTypedData(data) {
+        const { estimatedCost, code, message } = await this.sendRequest("orby_estimateFiatCostToSignTypedData", [{ data }]);
+        if (code && message) {
+            console.error("[estimateFiatCostToSignTypedData]", code, message);
+            return undefined;
+        }
+        return currency_amount_js_1.CurrencyAmount.toCurrencyAmount(estimatedCost);
+    }
+    async getOperationsToTransferToken(accountClusterId, standardizedTokenId, amount, recipient, gasToken) {
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const formattedRecepient = {
+            chainId: (0, utils_js_1.getOrbyChainId)(recipient.chainId),
+            recipientAddress: recipient.recipientAddress,
+        };
+        const operationSet = await this.sendRequest("orby_getOperationsToTransferToken", [
+            {
+                accountClusterId,
+                standardizedTokenId,
+                amount,
+                recipient: formattedRecepient,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    async getOperationsToSwap(accountClusterId, swapType, input, output, gasToken) {
+        const formattedInput = input
+            ? {
+                ...input,
+                tokenSources: input?.tokenSources.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const formattedOutput = output
+            ? {
+                ...output,
+                tokenDestination: output?.tokenDestination
+                    ? {
+                        chainId: (0, utils_js_1.getOrbyChainId)(output.tokenDestination.chainId),
+                        address: output.tokenDestination.address,
+                    }
+                    : undefined,
+            }
+            : undefined;
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToSwap", [
+            {
+                accountClusterId,
+                swapType,
+                input: formattedInput,
+                output: formattedOutput,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    async getQuote(accountClusterId, swapType, input, output) {
+        const formattedInput = input
+            ? {
+                ...input,
+                tokenSources: input?.tokenSources.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const formattedOutput = output
+            ? {
+                ...output,
+                tokenDestination: output?.tokenDestination
+                    ? {
+                        chainId: (0, utils_js_1.getOrbyChainId)(output.tokenDestination.chainId),
+                        address: output.tokenDestination.address,
+                    }
+                    : undefined,
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getQuote", [
+            {
+                accountClusterId,
+                swapType,
+                input: formattedInput,
+                output: formattedOutput,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    async getOperationsToBridge(accountClusterId, standardizedTokenId, amount, tokenSources, tokenDestination, gasToken) {
+        const formattedTokenSources = tokenSources.map(({ chainId, address }) => ({
+            chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+            address,
+        }));
+        const formattedDestination = tokenDestination
+            ? {
+                chainId: (0, utils_js_1.getOrbyChainId)(tokenDestination.chainId),
+                address: tokenDestination.address,
+            }
+            : undefined;
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToBridge", [
+            {
+                accountClusterId,
+                standardizedTokenId,
+                amount,
+                tokenSources: formattedTokenSources,
+                tokenDestination: formattedDestination,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
+    subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback, timout) {
+        let intervalId = null;
+        let totalWaitTime = 0;
+        const timeoutOrDefault = timout ?? 300_000;
+        if (ids && ids?.length > 0) {
+            const waitTime = 500;
+            intervalId = setInterval(async () => {
+                let statusSummary = enums_js_1.OperationStatusType.WAITING_PRECONDITION;
+                let primaryOperation;
+                try {
+                    const statuses = ids && ids?.length > 0
+                        ? await this?.getOperationStatuses(ids)
+                        : undefined;
+                    if (!ids || ids?.length == 0) {
+                        statusSummary = enums_js_1.OperationStatusType.NOT_FOUND;
+                    }
+                    else if (!statuses) {
+                        statusSummary = enums_js_1.OperationStatusType.NOT_FOUND;
+                    }
+                    else if (statuses.some((status) => status.status == enums_js_1.OperationStatusType.FAILED)) {
+                        statusSummary = enums_js_1.OperationStatusType.FAILED;
+                    }
+                    else if (statuses.every((status) => status.status == enums_js_1.OperationStatusType.SUCCESSFUL)) {
+                        statusSummary = enums_js_1.OperationStatusType.SUCCESSFUL;
+                    }
+                    primaryOperation = statuses?.find((status) => status.type == enums_js_1.OperationType.FINAL_TRANSACTION);
+                    if (primaryOperation?.status == enums_js_1.OperationStatusType.PENDING) {
+                        statusSummary = enums_js_1.OperationStatusType.PENDING;
+                    }
+                    onOperationStatusesUpdateCallback?.(statusSummary, primaryOperation, statuses);
+                }
+                catch (error) {
+                    console.error("[useWaitForStatusCompletion]", error);
+                }
+                finally {
+                    totalWaitTime += waitTime;
+                    if (intervalId &&
+                        enums_js_1.OperationStatusType.WAITING_PRECONDITION != statusSummary) {
+                        clearInterval(intervalId);
+                        intervalId = null;
+                    }
+                    else if (intervalId && totalWaitTime >= timeoutOrDefault) {
+                        // we cant wait for more than 2 ETH blocks
+                        clearInterval(intervalId);
+                        intervalId = null;
+                    }
+                }
+            }, waitTime);
+        }
+        return { intervalId };
+    }
+    async sendOperationSet(accountCluster, operationSet, signTransaction, signUserOperation, signTypedData) {
+        const signedOperations = [];
+        const operations = operationSet.intents
+            ?.map((intent) => intent.intentOperations)
+            .flat()
+            ?.concat(operationSet.primaryOperation)
+            .filter((value) => value != undefined && value != null);
+        if (operations?.length == 0) {
+            return { success: true, operationResponses: [] };
+        }
+        else if (!operations) {
+            return { success: false };
+        }
+        const hasPrimaryOperation = operations.find((operation) => operation.type == enums_js_1.OperationType.FINAL_TRANSACTION);
+        if (!hasPrimaryOperation) {
+            return { success: false };
+        }
+        const accountsMap = accountCluster.accounts.reduce((acc, account) => {
+            acc.set(account.key, account);
+            return acc;
+        }, new Map());
+        const smartAccountTransactions = operations.reduce((acc, operation) => {
+            const accountKey = account_js_1.Account.key(operation.from, operation.chainId);
+            const account = accountsMap.get(accountKey);
+            if (account?.accountType == enums_js_1.AccountType.SCA &&
+                operation.format == enums_js_1.OperationDataFormat.TRANSACTION) {
+                if (!acc.has(accountKey)) {
+                    acc.set(accountKey, []);
+                }
+                acc.get(accountKey).push(operation);
+            }
+            return acc;
+        }, new Map());
+        // Loop through all the operations and sign them
+        for (let i = 0; i < operations.length; i++) {
+            const operation = operations[i];
+            let signature;
+            if (operation.format == enums_js_1.OperationDataFormat.TRANSACTION) {
+                const accountKey = account_js_1.Account.key(operation.from, operation.chainId);
+                const account = accountsMap.get(accountKey);
+                // skip signing the transaction if the account is an SCA
+                if (account?.accountType == enums_js_1.AccountType.SCA) {
+                    continue;
+                }
+                signature = await signTransaction(operation);
+            }
+            else if (operation.format == enums_js_1.OperationDataFormat.TYPED_DATA) {
+                signature = await signTypedData(operation);
+            }
+            if (!signature) {
+                return { success: false };
+            }
+            signedOperations.push({
+                type: operation.type,
+                signature: signature,
+                data: operation.data,
+                from: operation.from,
+                chainId: (0, utils_js_1.getOrbyChainId)(operation.chainId),
+            });
+        }
+        // batch sign all the smart contract transactions
+        const accountKeys = Array.from(smartAccountTransactions.keys());
+        for (const accountKey of accountKeys) {
+            const transactions = smartAccountTransactions.get(accountKey);
+            transactions.sort((operationA, _) => {
+                if (operationA.type == enums_js_1.OperationType.APPROVE_ERC20_TOKEN) {
+                    return -1;
+                }
+                return 0;
+            });
+            const userOperation = await signUserOperation(transactions, transactions[0].from, transactions[0].chainId, transactions[0].txRpcUrl);
+            if (!userOperation) {
+                return { success: false };
+            }
+            const types = transactions.map((operation) => operation.type);
+            let type = types[0];
+            if (types.includes(enums_js_1.OperationType.FINAL_TRANSACTION)) {
+                type = enums_js_1.OperationType.FINAL_TRANSACTION;
+            }
+            else if (types.includes(enums_js_1.OperationType.SUBMIT_INTENT)) {
+                type = enums_js_1.OperationType.SUBMIT_INTENT;
+            }
+            signedOperations.push({
+                type,
+                signature: userOperation.signature,
+                data: JSON.stringify(userOperation),
+                from: transactions[0].from,
+                chainId: (0, utils_js_1.getOrbyChainId)(transactions[0].chainId),
+            });
+        }
+        const { operationSetId, operationResponses } = await this.sendSignedOperations(accountCluster.accountClusterId, signedOperations);
+        return {
+            operationSetId,
+            operationResponses,
+            success: true,
+            primaryOperationStatus: {
+                type: enums_js_1.OperationType.FINAL_TRANSACTION,
+                status: enums_js_1.OperationStatusType.WAITING_PRECONDITION,
+            },
+        };
+    }
+}
+exports.OperationActions = OperationActions;

package/dist/cjs/actions/token.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenActions = void 0;
+const action_helpers_js_1 = require("../utils/action_helpers.js");
+const library_request_js_1 = require("../entities/library_request.js");
+const utils_js_1 = require("../utils/utils.js");
+class TokenActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async getStandardizedTokenIds(tokens) {
+        const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
+            return { chainId: (0, utils_js_1.getOrbyChainId)(chainId), tokenAddress };
+        });
+        const { standardizedTokenIds, message, code } = await this.sendRequest("orby_getStandardizedTokenIds", [
+            {
+                tokens: formattedTokensInfo,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getStandardizedTokenIds]", code, message);
+            return undefined;
+        }
+        return standardizedTokenIds;
+    }
+    async getStandardizedTokens(tokens) {
+        const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
+            return { chainId: (0, utils_js_1.getOrbyChainId)(chainId), tokenAddress };
+        });
+        const { standardizedTokens, message, code } = await this.sendRequest("orby_getStandardizedTokens", [
+            {
+                tokens: formattedTokensInfo,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getStandardizedTokens]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractStandardizedTokens)(standardizedTokens);
+    }
+    async getFungibleTokenData(standardizedTokenIds) {
+        const { data, message, code } = await this.sendRequest("orby_getFungibleTokenData", [{ standardizedTokenIds }]);
+        if (code && message) {
+            console.error("[getFungibleTokenData]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractStandardizedTokens)(data);
+    }
+}
+exports.TokenActions = TokenActions;

package/dist/cjs/constants.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIAT_CURRENCY = exports.BLOCKCHAIN_ID_TO_BLOCKCHAIN = exports.CHAIN_CONFIGS = exports.BLOCKCHAIN_ID = exports.Big = void 0;
+const toformat_1 = __importDefault(require("toformat"));
+const big_js_1 = __importDefault(require("big.js"));
+const enums_js_1 = require("./enums.js");
+const currency_js_1 = require("./entities/financial/currency.js");
+exports.Big = (0, toformat_1.default)(big_js_1.default);
+exports.BLOCKCHAIN_ID = {
+    [enums_js_1.Blockchain.ETHEREUM]: 1,
+    [enums_js_1.Blockchain.POLYGON]: 137,
+    [enums_js_1.Blockchain.BINANCE]: 56,
+    [enums_js_1.Blockchain.ARBITRUM]: 42161,
+    [enums_js_1.Blockchain.ARBITRUM_NOVA]: 42170,
+    [enums_js_1.Blockchain.OPTIMISM]: 10,
+    [enums_js_1.Blockchain.EVMOS]: 9001,
+    [enums_js_1.Blockchain.MOONBEAM]: 1284,
+    [enums_js_1.Blockchain.BASE]: 8453,
+    [enums_js_1.Blockchain.AVALANCHE]: 43114,
+    // testnets
+    [enums_js_1.Blockchain.ETHEREUM_SEPOLIA]: 11155111,
+    [enums_js_1.Blockchain.ETHEREUM_HOLESKY]: 17000,
+    [enums_js_1.Blockchain.ARBITRUM_SEPOLIA]: 421614,
+    [enums_js_1.Blockchain.OPTIMISM_SEPOLIA]: 11155420,
+    [enums_js_1.Blockchain.POLYGON_AMOY]: 80002,
+    [enums_js_1.Blockchain.BINANCE_TESTNET]: 97,
+    [enums_js_1.Blockchain.OPBNB_TESTNET]: 5611,
+    [enums_js_1.Blockchain.MOONBEAM_ALPHA]: 1287,
+    [enums_js_1.Blockchain.BASE_SEPOLIA]: 84532,
+    // local testing
+    [enums_js_1.Blockchain.HARDHAT]: 31337,
+    [enums_js_1.Blockchain.LOCAL_CHAIN_0]: 1_000_000_000_001,
+    [enums_js_1.Blockchain.LOCAL_CHAIN_1]: 1_000_000_000_002,
+};
+exports.CHAIN_CONFIGS = {
+    [enums_js_1.Blockchain.ETHEREUM]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(1),
+    },
+    [enums_js_1.Blockchain.POLYGON]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(137),
+    },
+    [enums_js_1.Blockchain.BINANCE]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(56),
+    },
+    [enums_js_1.Blockchain.ARBITRUM]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(42161),
+    },
+    [enums_js_1.Blockchain.ARBITRUM_NOVA]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(42170),
+    },
+    [enums_js_1.Blockchain.OPTIMISM]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(10),
+    },
+    [enums_js_1.Blockchain.EVMOS]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(9001),
+    },
+    [enums_js_1.Blockchain.MOONBEAM]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(1284),
+    },
+    [enums_js_1.Blockchain.BASE]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(8453),
+    },
+    [enums_js_1.Blockchain.AVALANCHE]: {
+        environment: enums_js_1.BlockchainEnvironment.MAINNET,
+        chainId: BigInt(43114),
+    },
+    // testnets
+    [enums_js_1.Blockchain.ETHEREUM_SEPOLIA]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(11155111),
+    },
+    [enums_js_1.Blockchain.ETHEREUM_HOLESKY]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(17000),
+    },
+    [enums_js_1.Blockchain.ARBITRUM_SEPOLIA]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(421614),
+    },
+    [enums_js_1.Blockchain.BASE_SEPOLIA]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(84532),
+    },
+    [enums_js_1.Blockchain.OPTIMISM_SEPOLIA]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(11155420),
+    },
+    [enums_js_1.Blockchain.BINANCE_TESTNET]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(97),
+    },
+    [enums_js_1.Blockchain.OPBNB_TESTNET]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(5611),
+    },
+    [enums_js_1.Blockchain.MOONBEAM_ALPHA]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(1287),
+    },
+    [enums_js_1.Blockchain.POLYGON_AMOY]: {
+        environment: enums_js_1.BlockchainEnvironment.TESTNET,
+        chainId: BigInt(80002),
+    },
+};
+exports.BLOCKCHAIN_ID_TO_BLOCKCHAIN = {
+    [1]: enums_js_1.Blockchain.ETHEREUM,
+    [137]: enums_js_1.Blockchain.POLYGON,
+    [56]: enums_js_1.Blockchain.BINANCE,
+    [42161]: enums_js_1.Blockchain.ARBITRUM,
+    [42170]: enums_js_1.Blockchain.ARBITRUM_NOVA,
+    [10]: enums_js_1.Blockchain.OPTIMISM,
+    [9001]: enums_js_1.Blockchain.EVMOS,
+    [1284]: enums_js_1.Blockchain.MOONBEAM,
+    [8453]: enums_js_1.Blockchain.BASE,
+    [43114]: enums_js_1.Blockchain.AVALANCHE,
+    // testnets
+    [11155111]: enums_js_1.Blockchain.ETHEREUM_SEPOLIA,
+    [84532]: enums_js_1.Blockchain.BASE_SEPOLIA,
+    [17000]: enums_js_1.Blockchain.ETHEREUM_HOLESKY,
+    [421614]: enums_js_1.Blockchain.ARBITRUM_SEPOLIA,
+    [11155420]: enums_js_1.Blockchain.OPTIMISM_SEPOLIA,
+    [80002]: enums_js_1.Blockchain.POLYGON_AMOY,
+    [97]: enums_js_1.Blockchain.BINANCE_TESTNET,
+    [5611]: enums_js_1.Blockchain.OPBNB_TESTNET,
+    [1287]: enums_js_1.Blockchain.MOONBEAM_ALPHA,
+};
+exports.FIAT_CURRENCY = new currency_js_1.Currency(6, "USD", "US Dollar", undefined, false, false);

package/dist/cjs/entities/account.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+const enums_js_1 = require("../enums.js");
+const utils_js_1 = require("../utils/utils.js");
+class Account {
+    static toAccount(account) {
+        const chainId = account?.chainId
+            ? (0, utils_js_1.getChainIdFromOrbyChainId)(account.chainId)
+            : undefined;
+        const formattedAccountType = account?.accountType;
+        if (!chainId && formattedAccountType == enums_js_1.AccountType.SCA) {
+            return undefined;
+        }
+        return new Account(account.address, formattedAccountType, account.vmType, chainId);
+    }
+    constructor(address, accountType, vmType, chainId) {
+        // TODO(felix): add this back
+        // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
+        this.address = address?.toLowerCase(); // validateAndParseAddress(address)?.toLowerCase();
+        this.chainId = chainId ? BigInt(chainId) : undefined;
+        this.accountType = accountType;
+        this.vmType = vmType;
+        this.key = Account.key(address, chainId);
+        if (this.accountType == enums_js_1.AccountType.SCA) {
+            this.hasSufficientBalanceForGas = true;
+        }
+        else {
+            this.hasSufficientBalanceForGas = false;
+        }
+    }
+    static key(address, chainId) {
+        return chainId
+            ? `${chainId?.toString()?.toLowerCase()}-${address}`
+            : address;
+    }
+    toAccountModel() {
+        return {
+            address: this.address,
+            accountType: this.accountType?.toUpperCase(),
+            vmType: this.vmType?.toUpperCase(),
+            chainId: this.chainId ? "EIP155-" + this.chainId : undefined,
+        };
+    }
+    equals(other) {
+        return this.key == other?.key && this.accountType == other?.accountType;
+    }
+}
+exports.Account = Account;

package/dist/cjs/entities/financial/account_balance.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountBalance = void 0;
+const account_js_1 = require("../account.js");
+const fungible_token_amount_js_1 = require("./fungible_token_amount.js");
+class AccountBalance {
+    static toAccountBalance(balance) {
+        if (!balance) {
+            return undefined;
+        }
+        const amount = fungible_token_amount_js_1.FungibleTokenAmount.toFungibleTokenAmount(balance.amount);
+        const account = account_js_1.Account.toAccount(balance.account);
+        return new AccountBalance(amount, account);
+    }
+    constructor(amount, account) {
+        this.amount = amount;
+        this.account = account;
+    }
+    equals(other) {
+        return (this.account.equals(other.account) && this.amount.equals(other.amount));
+    }
+    lessThan(other) {
+        return (this.account.equals(other.account) && this.amount.lessThan(other.amount));
+    }
+    greaterThan(other) {
+        return (this.account.equals(other.account) &&
+            this.amount.greaterThan(other.amount));
+    }
+    greaterThanOrEqual(other) {
+        return (this.account.equals(other.account) &&
+            (this.amount.greaterThan(other.amount) ||
+                this.amount.equals(other.amount)));
+    }
+}
+exports.AccountBalance = AccountBalance;