@orb-labs/orby-core 0.0.13 → 0.0.15

package/dist/cjs/entities/financial/semi_fungible_token.d.ts

@@ -0,0 +1,41 @@
+import { Currency } from "./currency.js";
+import { TokenType } from "../../enums.js";
+/**
+ * Represents an ERC1155 token with a unique address and some metadata.
+ */
+export declare class SemiFungibleToken extends Currency {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * The chain ID on which this token resides
+     */
+    readonly chainId: bigint;
+    readonly url?: string;
+    /**
+     *
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link Currency#decimals}
+     * @param symbol {@link Currency#symbol}
+     * @param name {@link Currency#name}
+     * @param url The URL of the token's metadata
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     */
+    constructor(chainId: bigint, address: string, decimals: number, symbol: string, name: string, url?: string, bypassChecksum?: boolean, coinGeckoId?: string);
+    static toSemiFungibleToken(sft?: any): SemiFungibleToken;
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: SemiFungibleToken): boolean;
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency(): Currency;
+    type(): TokenType;
+    identifier(): string;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemiFungibleToken = void 0;
+const currency_js_1 = require("./currency.js");
+const validateAndParseAddress_js_1 = require("../../utils/validateAndParseAddress.js");
+const enums_js_1 = require("../../enums.js");
+/**
+ * Represents an ERC1155 token with a unique address and some metadata.
+ */
+class SemiFungibleToken extends currency_js_1.Currency {
+    /**
+     *
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link Currency#decimals}
+     * @param symbol {@link Currency#symbol}
+     * @param name {@link Currency#name}
+     * @param url The URL of the token's metadata
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     */
+    constructor(chainId, address, decimals, symbol, name, url, bypassChecksum, coinGeckoId) {
+        // TODO(felix): add this back
+        // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
+        super(decimals, symbol, name, url, false, true, coinGeckoId);
+        this.isNative = false;
+        this.isToken = true;
+        if (bypassChecksum) {
+            this.address = (0, validateAndParseAddress_js_1.checkValidAddress)(address)?.toLowerCase();
+        }
+        else {
+            this.address = (0, validateAndParseAddress_js_1.validateAndParseAddress)(address)?.toLowerCase();
+        }
+        this.chainId = chainId;
+        this.url = url;
+    }
+    static toSemiFungibleToken(sft) {
+        if (!sft) {
+            return undefined;
+        }
+        const currency = currency_js_1.Currency.toCurrency(sft.currency);
+        return new SemiFungibleToken(sft.chainId, sft.address, currency.decimals, currency.symbol, currency.name, sft.url);
+    }
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other) {
+        // short circuit on reference equality
+        if (this === other)
+            return true;
+        return (this.chainId === other.chainId &&
+            this.address === other.address.toLowerCase());
+    }
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency() {
+        return this;
+    }
+    type() {
+        return enums_js_1.TokenType.SEMI_FUNGIBLE_TOKEN;
+    }
+    identifier() {
+        return `${this.chainId}+${this.address.toLowerCase()}`;
+    }
+}
+exports.SemiFungibleToken = SemiFungibleToken;

package/dist/cjs/entities/library_request.d.ts

@@ -0,0 +1,8 @@
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class LibraryRequest {
+    readonly library: LIBRARY_TYPE;
+    readonly client?: any;
+    readonly provider?: any;
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    sendRequest(method: string, params: any[]): Promise<any>;
+}

package/dist/cjs/entities/library_request.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryRequest = void 0;
+const enums_js_1 = require("../enums.js");
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+class LibraryRequest {
+    constructor(library, client, provider) {
+        if (library == enums_js_1.LIBRARY_TYPE.VIEM) {
+            (0, tiny_invariant_1.default)(client, "CLIENT");
+            (0, tiny_invariant_1.default)(!provider, "PROVIDER");
+            this.client = client;
+        }
+        else if (library == enums_js_1.LIBRARY_TYPE.ETHERS) {
+            (0, tiny_invariant_1.default)(provider, "PROVIDER");
+            (0, tiny_invariant_1.default)(!client, "CLIENT");
+            this.provider = provider;
+        }
+        else {
+            (0, tiny_invariant_1.default)(false, "LIBRARY");
+        }
+        this.library = library;
+        this.client = client;
+        this.provider = provider;
+    }
+    sendRequest(method, params) {
+        if (this.library == enums_js_1.LIBRARY_TYPE.VIEM) {
+            return this.client.request({ method, params });
+        }
+        else if (this.library == enums_js_1.LIBRARY_TYPE.ETHERS) {
+            return this.provider.send(method, params);
+        }
+    }
+}
+exports.LibraryRequest = LibraryRequest;

package/dist/cjs/entities/state.d.ts

@@ -0,0 +1,22 @@
+import { FungibleToken } from "./financial/fungible_token.js";
+import { FungibleTokenAmount } from "./financial/fungible_token_amount.js";
+import { NonFungibleToken } from "./financial/non_fungible_token.js";
+import { SemiFungibleToken } from "./financial/semi_fungible_token.js";
+export declare class State {
+    private readonly fungibleTokens;
+    private readonly nonFungibleTokens;
+    private readonly semiFungibleTokens;
+    constructor(fungibleTokens: FungibleTokenAmount[], nonFungibleTokens: NonFungibleToken[], semiFungibleTokens: SemiFungibleToken[]);
+    static fromFungibleTokenAmounts(fungibleTokenAmounts: FungibleTokenAmount[]): State;
+    static fromTokenAndAmount(token?: FungibleToken, amount?: bigint): State;
+    getFungibleTokens(): FungibleTokenAmount[];
+    getNonFungibleTokens(): NonFungibleToken[];
+    getSemiFungibleTokens(): SemiFungibleToken[];
+    addTokens(fungibleTokens: FungibleTokenAmount[]): State;
+    addState(other: State): State;
+    deductState(other: State): State;
+    equals(other?: State): boolean;
+    addStates(states: State[]): State;
+    static mergeStates(states: State[]): State;
+    static toState(state: any): State;
+}

package/dist/cjs/entities/state.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+const fungible_token_amount_js_1 = require("./financial/fungible_token_amount.js");
+const non_fungible_token_js_1 = require("./financial/non_fungible_token.js");
+const semi_fungible_token_js_1 = require("./financial/semi_fungible_token.js");
+class State {
+    constructor(fungibleTokens, nonFungibleTokens, semiFungibleTokens) {
+        this.fungibleTokens = fungibleTokens.reduce((acc, amount) => {
+            acc.set(amount.token.identifier(), amount);
+            return acc;
+        }, new Map());
+        this.nonFungibleTokens = nonFungibleTokens.reduce((acc, token) => {
+            acc.set(token.identifier(), token);
+            return acc;
+        }, new Map());
+        this.semiFungibleTokens = semiFungibleTokens.reduce((acc, token) => {
+            acc.set(token.identifier(), token);
+            return acc;
+        }, new Map());
+    }
+    static fromFungibleTokenAmounts(fungibleTokenAmounts) {
+        return new State(fungibleTokenAmounts, [], []);
+    }
+    static fromTokenAndAmount(token, amount) {
+        if (!token || !amount) {
+            return undefined;
+        }
+        const fungibleTokenAmount = fungible_token_amount_js_1.FungibleTokenAmount.fromRawAmount(token, amount);
+        return State.fromFungibleTokenAmounts([fungibleTokenAmount]);
+    }
+    getFungibleTokens() {
+        return Array.from(this.fungibleTokens.values());
+    }
+    getNonFungibleTokens() {
+        return Array.from(this.nonFungibleTokens.values());
+    }
+    getSemiFungibleTokens() {
+        return Array.from(this.semiFungibleTokens.values());
+    }
+    addTokens(fungibleTokens) {
+        fungibleTokens.forEach((amount) => {
+            const identifier = amount.token.identifier();
+            const currentAmount = this.fungibleTokens.get(identifier);
+            if (currentAmount) {
+                this.fungibleTokens.set(identifier, currentAmount.add(amount));
+            }
+            else {
+                this.fungibleTokens.set(identifier, amount);
+            }
+        });
+        return this;
+    }
+    addState(other) {
+        other?.fungibleTokens?.forEach((amount) => {
+            const identifier = amount.token.identifier();
+            const currentAmount = this.fungibleTokens.get(identifier);
+            if (currentAmount) {
+                this.fungibleTokens.set(identifier, currentAmount.add(amount));
+            }
+            else {
+                this.fungibleTokens.set(identifier, amount);
+            }
+        });
+        return this;
+    }
+    deductState(other) {
+        other.fungibleTokens.forEach((amount) => {
+            const identifier = amount.token.identifier();
+            const currentAmount = this.fungibleTokens.get(identifier);
+            if (currentAmount?.toRawAmount() > amount?.toRawAmount()) {
+                this.fungibleTokens.set(identifier, currentAmount.subtract(amount));
+            }
+            else if (currentAmount) {
+                this.fungibleTokens.delete(identifier);
+            }
+        });
+        return this;
+    }
+    equals(other) {
+        if (!other) {
+            return false;
+        }
+        return (this.fungibleTokens.size == other.fungibleTokens.size &&
+            Array.from(this.fungibleTokens.entries()).every(([key, value]) => {
+                const otherValue = other.fungibleTokens.get(key);
+                return otherValue && value.equals(otherValue);
+            }));
+    }
+    addStates(states) {
+        states.forEach((state) => this.addState(state));
+        return this;
+    }
+    static mergeStates(states) {
+        return states.reduce((acc, state) => acc.addState(state), new State([], [], []));
+    }
+    static toState(state) {
+        if (!state)
+            return undefined;
+        const fungibleTokenAmounts = state.fungibleTokenAmounts.map((ft) => fungible_token_amount_js_1.FungibleTokenAmount.toFungibleTokenAmount(ft));
+        const nonFungibleTokenAmounts = state.nonFungibleTokenAmounts.map((nft) => non_fungible_token_js_1.NonFungibleToken.toNonFungibleToken(nft));
+        const semiFungibleTokenAmounts = state.semiFungibleTokenAmounts.map((sft) => semi_fungible_token_js_1.SemiFungibleToken.toSemiFungibleToken(sft));
+        return new State(fungibleTokenAmounts, nonFungibleTokenAmounts, semiFungibleTokenAmounts);
+    }
+}
+exports.State = State;

package/dist/cjs/enums.d.ts

@@ -0,0 +1,116 @@
+export declare enum Blockchain {
+    ETHEREUM = "ethereum",
+    POLYGON = "polygon",
+    BINANCE = "binance",
+    ARBITRUM = "arbitrum",
+    BASE = "base",
+    AVALANCHE = "avalanche",
+    ARBITRUM_NOVA = "arbitrum_nova",
+    OPTIMISM = "optimism",
+    EVMOS = "evmos",
+    MOONBEAM = "moonbeam",
+    ETHEREUM_SEPOLIA = "ethereum_sepolia",
+    ETHEREUM_HOLESKY = "ethereum_holesky",
+    BASE_SEPOLIA = "base_sepolia",
+    ARBITRUM_SEPOLIA = "arbitrum_sepolia",
+    OPTIMISM_SEPOLIA = "optimism_sepolia",
+    POLYGON_AMOY = "polygon_amoy",
+    BINANCE_TESTNET = "binance_testnet",
+    OPBNB_TESTNET = "opbnb_testnet",
+    MOONBEAM_ALPHA = "moonbeam_alpha",
+    HARDHAT = "hardhat",
+    LOCAL_CHAIN_0 = "local_chain_0",
+    LOCAL_CHAIN_1 = "local_chain_1"
+}
+export declare enum TokenType {
+    FUNGIBLE_TOKEN = "FUNGIBLE_TOKEN",
+    NON_FUNGIBLE_TOKEN = "NON_FUNGIBLE_TOKEN",
+    SEMI_FUNGIBLE_TOKEN = "SEMI_FUNGIBLE_TOKEN",
+    FIAT = "FIAT"
+}
+export declare enum AccountType {
+    EOA = "EOA",
+    SCA = "SCA"
+}
+export declare enum VMType {
+    EVM = "EVM"
+}
+export declare enum ChainSupportStatus {
+    CHAIN_SUPPORTED = "CHAIN_SUPPORTED",
+    CHAIN_UNAVAILABLE = "CHAIN_UNAVAILABLE",
+    ACCOUNT_UNAVAILABLE = "ACCOUNT_UNAVAILABLE"
+}
+export declare enum CreateOperationsStatus {
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    INSUFFICIENT_FUNDS_FOR_GAS = "INSUFFICIENT_FUNDS_FOR_GAS",
+    INTERNAL = "INTERNAL",
+    INVALID_ARGUMENT = "INVALID_ARGUMENT",
+    NO_EXECUTION_PATH = "NO_EXECUTION_PATH",
+    SUCCESS = "SUCCESS"
+}
+export declare enum OperationDataFormat {
+    TRANSACTION = "TRANSACTION",
+    TYPED_DATA = "TYPED_DATA"
+}
+export declare enum OperationType {
+    APPROVE_ERC20_TOKEN = "APPROVE_ERC20_TOKEN",
+    CANCEL_OPERATION = "CANCEL_OPERATION",
+    CANCEL_TRANSACTION = "CANCEL_TRANSACTION",
+    FINAL_TRANSACTION = "FINAL_TRANSACTION",
+    GAS_ABSTRACTION = "GAS_ABSTRACTION",
+    NATIVE_TOKEN_TRANSFER = "NATIVE_TOKEN_TRANSFER",
+    SUBMIT_INTENT = "SUBMIT_INTENT"
+}
+export declare enum Category {
+    SEND = "SEND",
+    RECEIVE = "RECEIVE",
+    SWAP = "SWAP",
+    REBALANCE = "REBALANCE",
+    BRIDGE = "BRIDGE",
+    FUNCTION_CALL = "FUNCTION_CALL",
+    TYPED_DATA_SIGNATURE = "TYPED_DATA_SIGNATURE"
+}
+export declare enum OperationStatusType {
+    FAILED = "FAILED",
+    NOT_FOUND = "NOT_FOUND",
+    PENDING = "PENDING",
+    SUCCESSFUL = "SUCCESSFUL",
+    WAITING_PRECONDITION = "WAITING_PRECONDITION"
+}
+export declare enum QuoteType {
+    EXACT_INPUT = "EXACT_INPUT",
+    EXACT_OUTPUT = "EXACT_OUTPUT"
+}
+export declare enum Order {
+    NEWEST = "NEWEST",
+    OLDEST = "OLDEST"
+}
+export declare enum ActivityStatus {
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS"
+}
+export declare enum BlockchainEnvironment {
+    MAINNET = "MAINNET",
+    TESTNET = "TESTNET"
+}
+export declare enum TokenAllowlistType {
+    ALL_TOKENS = "ALL_TOKENS",
+    ONLY_FUNGIBLE_TOKENS = "ONLY_FUNGIBLE_TOKENS",
+    ONLY_NON_FUNGIBLE_TOKENS = "ONLY_NON_FUNGIBLE_TOKENS",
+    ONLY_SEMI_FUNGIBLE_TOKENS = "ONLY_SEMI_FUNGIBLE_TOKENS"
+}
+export declare enum TimeIntervalUnits {
+    DAYS = "DAYS",
+    FOREVER = "FOREVER",
+    HOURS = "HOURS",
+    MINUTES = "MINUTES",
+    MONTHS = "MONTHS",
+    WEEKS = "WEEKS",
+    YEARS = "YEARS"
+}
+export declare enum LIBRARY_TYPE {
+    VIEM = "VIEM",
+    ETHERS = "ETHERS"
+}

package/dist/cjs/enums.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIBRARY_TYPE = exports.TimeIntervalUnits = exports.TokenAllowlistType = exports.BlockchainEnvironment = exports.ActivityStatus = exports.Order = exports.QuoteType = exports.OperationStatusType = exports.Category = exports.OperationType = exports.OperationDataFormat = exports.CreateOperationsStatus = exports.ChainSupportStatus = exports.VMType = exports.AccountType = exports.TokenType = exports.Blockchain = void 0;
+var Blockchain;
+(function (Blockchain) {
+    Blockchain["ETHEREUM"] = "ethereum";
+    Blockchain["POLYGON"] = "polygon";
+    Blockchain["BINANCE"] = "binance";
+    Blockchain["ARBITRUM"] = "arbitrum";
+    Blockchain["BASE"] = "base";
+    Blockchain["AVALANCHE"] = "avalanche";
+    Blockchain["ARBITRUM_NOVA"] = "arbitrum_nova";
+    Blockchain["OPTIMISM"] = "optimism";
+    Blockchain["EVMOS"] = "evmos";
+    Blockchain["MOONBEAM"] = "moonbeam";
+    // testnets
+    Blockchain["ETHEREUM_SEPOLIA"] = "ethereum_sepolia";
+    Blockchain["ETHEREUM_HOLESKY"] = "ethereum_holesky";
+    Blockchain["BASE_SEPOLIA"] = "base_sepolia";
+    Blockchain["ARBITRUM_SEPOLIA"] = "arbitrum_sepolia";
+    Blockchain["OPTIMISM_SEPOLIA"] = "optimism_sepolia";
+    Blockchain["POLYGON_AMOY"] = "polygon_amoy";
+    Blockchain["BINANCE_TESTNET"] = "binance_testnet";
+    Blockchain["OPBNB_TESTNET"] = "opbnb_testnet";
+    Blockchain["MOONBEAM_ALPHA"] = "moonbeam_alpha";
+    // local testing
+    Blockchain["HARDHAT"] = "hardhat";
+    Blockchain["LOCAL_CHAIN_0"] = "local_chain_0";
+    Blockchain["LOCAL_CHAIN_1"] = "local_chain_1";
+})(Blockchain || (exports.Blockchain = Blockchain = {}));
+var TokenType;
+(function (TokenType) {
+    TokenType["FUNGIBLE_TOKEN"] = "FUNGIBLE_TOKEN";
+    TokenType["NON_FUNGIBLE_TOKEN"] = "NON_FUNGIBLE_TOKEN";
+    TokenType["SEMI_FUNGIBLE_TOKEN"] = "SEMI_FUNGIBLE_TOKEN";
+    TokenType["FIAT"] = "FIAT";
+})(TokenType || (exports.TokenType = TokenType = {}));
+var AccountType;
+(function (AccountType) {
+    AccountType["EOA"] = "EOA";
+    AccountType["SCA"] = "SCA";
+})(AccountType || (exports.AccountType = AccountType = {}));
+var VMType;
+(function (VMType) {
+    VMType["EVM"] = "EVM";
+})(VMType || (exports.VMType = VMType = {}));
+var ChainSupportStatus;
+(function (ChainSupportStatus) {
+    ChainSupportStatus["CHAIN_SUPPORTED"] = "CHAIN_SUPPORTED";
+    ChainSupportStatus["CHAIN_UNAVAILABLE"] = "CHAIN_UNAVAILABLE";
+    ChainSupportStatus["ACCOUNT_UNAVAILABLE"] = "ACCOUNT_UNAVAILABLE";
+})(ChainSupportStatus || (exports.ChainSupportStatus = ChainSupportStatus = {}));
+var CreateOperationsStatus;
+(function (CreateOperationsStatus) {
+    CreateOperationsStatus["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+    CreateOperationsStatus["INSUFFICIENT_FUNDS_FOR_GAS"] = "INSUFFICIENT_FUNDS_FOR_GAS";
+    CreateOperationsStatus["INTERNAL"] = "INTERNAL";
+    CreateOperationsStatus["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+    CreateOperationsStatus["NO_EXECUTION_PATH"] = "NO_EXECUTION_PATH";
+    CreateOperationsStatus["SUCCESS"] = "SUCCESS";
+})(CreateOperationsStatus || (exports.CreateOperationsStatus = CreateOperationsStatus = {}));
+var OperationDataFormat;
+(function (OperationDataFormat) {
+    OperationDataFormat["TRANSACTION"] = "TRANSACTION";
+    OperationDataFormat["TYPED_DATA"] = "TYPED_DATA";
+})(OperationDataFormat || (exports.OperationDataFormat = OperationDataFormat = {}));
+var OperationType;
+(function (OperationType) {
+    OperationType["APPROVE_ERC20_TOKEN"] = "APPROVE_ERC20_TOKEN";
+    OperationType["CANCEL_OPERATION"] = "CANCEL_OPERATION";
+    OperationType["CANCEL_TRANSACTION"] = "CANCEL_TRANSACTION";
+    OperationType["FINAL_TRANSACTION"] = "FINAL_TRANSACTION";
+    OperationType["GAS_ABSTRACTION"] = "GAS_ABSTRACTION";
+    OperationType["NATIVE_TOKEN_TRANSFER"] = "NATIVE_TOKEN_TRANSFER";
+    OperationType["SUBMIT_INTENT"] = "SUBMIT_INTENT";
+})(OperationType || (exports.OperationType = OperationType = {}));
+var Category;
+(function (Category) {
+    Category["SEND"] = "SEND";
+    Category["RECEIVE"] = "RECEIVE";
+    Category["SWAP"] = "SWAP";
+    Category["REBALANCE"] = "REBALANCE";
+    Category["BRIDGE"] = "BRIDGE";
+    Category["FUNCTION_CALL"] = "FUNCTION_CALL";
+    Category["TYPED_DATA_SIGNATURE"] = "TYPED_DATA_SIGNATURE";
+})(Category || (exports.Category = Category = {}));
+var OperationStatusType;
+(function (OperationStatusType) {
+    OperationStatusType["FAILED"] = "FAILED";
+    OperationStatusType["NOT_FOUND"] = "NOT_FOUND";
+    OperationStatusType["PENDING"] = "PENDING";
+    OperationStatusType["SUCCESSFUL"] = "SUCCESSFUL";
+    OperationStatusType["WAITING_PRECONDITION"] = "WAITING_PRECONDITION";
+})(OperationStatusType || (exports.OperationStatusType = OperationStatusType = {}));
+var QuoteType;
+(function (QuoteType) {
+    QuoteType["EXACT_INPUT"] = "EXACT_INPUT";
+    QuoteType["EXACT_OUTPUT"] = "EXACT_OUTPUT";
+})(QuoteType || (exports.QuoteType = QuoteType = {}));
+var Order;
+(function (Order) {
+    Order["NEWEST"] = "NEWEST";
+    Order["OLDEST"] = "OLDEST";
+})(Order || (exports.Order = Order = {}));
+var ActivityStatus;
+(function (ActivityStatus) {
+    ActivityStatus["CANCELLED"] = "CANCELLED";
+    ActivityStatus["FAILED"] = "FAILED";
+    ActivityStatus["PENDING"] = "PENDING";
+    ActivityStatus["SUCCESS"] = "SUCCESS";
+})(ActivityStatus || (exports.ActivityStatus = ActivityStatus = {}));
+var BlockchainEnvironment;
+(function (BlockchainEnvironment) {
+    BlockchainEnvironment["MAINNET"] = "MAINNET";
+    BlockchainEnvironment["TESTNET"] = "TESTNET";
+})(BlockchainEnvironment || (exports.BlockchainEnvironment = BlockchainEnvironment = {}));
+var TokenAllowlistType;
+(function (TokenAllowlistType) {
+    TokenAllowlistType["ALL_TOKENS"] = "ALL_TOKENS";
+    TokenAllowlistType["ONLY_FUNGIBLE_TOKENS"] = "ONLY_FUNGIBLE_TOKENS";
+    TokenAllowlistType["ONLY_NON_FUNGIBLE_TOKENS"] = "ONLY_NON_FUNGIBLE_TOKENS";
+    TokenAllowlistType["ONLY_SEMI_FUNGIBLE_TOKENS"] = "ONLY_SEMI_FUNGIBLE_TOKENS";
+})(TokenAllowlistType || (exports.TokenAllowlistType = TokenAllowlistType = {}));
+var TimeIntervalUnits;
+(function (TimeIntervalUnits) {
+    TimeIntervalUnits["DAYS"] = "DAYS";
+    TimeIntervalUnits["FOREVER"] = "FOREVER";
+    TimeIntervalUnits["HOURS"] = "HOURS";
+    TimeIntervalUnits["MINUTES"] = "MINUTES";
+    TimeIntervalUnits["MONTHS"] = "MONTHS";
+    TimeIntervalUnits["WEEKS"] = "WEEKS";
+    TimeIntervalUnits["YEARS"] = "YEARS";
+})(TimeIntervalUnits || (exports.TimeIntervalUnits = TimeIntervalUnits = {}));
+var LIBRARY_TYPE;
+(function (LIBRARY_TYPE) {
+    LIBRARY_TYPE["VIEM"] = "VIEM";
+    LIBRARY_TYPE["ETHERS"] = "ETHERS";
+})(LIBRARY_TYPE || (exports.LIBRARY_TYPE = LIBRARY_TYPE = {}));

package/dist/cjs/index.d.ts

@@ -0,0 +1,29 @@
+export * from "./interfaces/account_cluster.js";
+export * from "./interfaces/admin.js";
+export * from "./interfaces/application.js";
+export * from "./interfaces/instance.js";
+export * from "./interfaces/operation.js";
+export * from "./interfaces/token.js";
+export * from "./interfaces/orby.js";
+export * from "./interfaces/blockchain.js";
+export * from "./actions/account_cluster.js";
+export * from "./actions/admin.js";
+export * from "./actions/application.js";
+export * from "./actions/instance.js";
+export * from "./actions/operation.js";
+export * from "./actions/token.js";
+export * from "./actions/blockchain.js";
+export * from "./entities/financial/account_balance.js";
+export * from "./entities/financial/asset.js";
+export * from "./entities/financial/currency_amount.js";
+export * from "./entities/financial/currency.js";
+export * from "./entities/financial/fungible_token_amount.js";
+export * from "./entities/financial/fungible_token.js";
+export * from "./entities/financial/non_fungible_token.js";
+export * from "./entities/financial/semi_fungible_token.js";
+export * from "./entities/account.js";
+export * from "./entities/state.js";
+export * from "./enums.js";
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils/utils.js";

package/dist/cjs/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// interfaces
+__exportStar(require("./interfaces/account_cluster.js"), exports);
+__exportStar(require("./interfaces/admin.js"), exports);
+__exportStar(require("./interfaces/application.js"), exports);
+__exportStar(require("./interfaces/instance.js"), exports);
+__exportStar(require("./interfaces/operation.js"), exports);
+__exportStar(require("./interfaces/token.js"), exports);
+__exportStar(require("./interfaces/orby.js"), exports);
+__exportStar(require("./interfaces/blockchain.js"), exports);
+// actions
+__exportStar(require("./actions/account_cluster.js"), exports);
+__exportStar(require("./actions/admin.js"), exports);
+__exportStar(require("./actions/application.js"), exports);
+__exportStar(require("./actions/instance.js"), exports);
+__exportStar(require("./actions/operation.js"), exports);
+__exportStar(require("./actions/token.js"), exports);
+__exportStar(require("./actions/blockchain.js"), exports);
+// entities
+__exportStar(require("./entities/financial/account_balance.js"), exports);
+__exportStar(require("./entities/financial/asset.js"), exports);
+__exportStar(require("./entities/financial/currency_amount.js"), exports);
+__exportStar(require("./entities/financial/currency.js"), exports);
+__exportStar(require("./entities/financial/fungible_token_amount.js"), exports);
+__exportStar(require("./entities/financial/fungible_token.js"), exports);
+__exportStar(require("./entities/financial/non_fungible_token.js"), exports);
+__exportStar(require("./entities/financial/semi_fungible_token.js"), exports);
+__exportStar(require("./entities/account.js"), exports);
+__exportStar(require("./entities/state.js"), exports);
+// enums, types and constants
+__exportStar(require("./enums.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./utils/utils.js"), exports);

package/dist/cjs/interfaces/account_cluster.d.ts

@@ -0,0 +1,30 @@
+import { Account } from "../entities/account.js";
+import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StandardizedBalance, VirtualNodeRpcUrlForSupportedChain } from "../types.js";
+import { ChainSupportStatus, Order } from "../enums.js";
+export interface IAccountClusterActions {
+    createAccountCluster(accounts: Account[]): Promise<AccountCluster>;
+    addToAccountCluster(accounts: Account[], accountClusterId: string): Promise<AccountCluster>;
+    removeFromAccountCluster(accounts: Account[], accountClusterId: string): Promise<AccountCluster>;
+    getVirtualNodeRpcUrlsForSupportedChains(accountClusterId: string): Promise<VirtualNodeRpcUrlForSupportedChain[]>;
+    enableChainAbstractionForAccountCluster(accountClusterId: string, enable: boolean): Promise<boolean>;
+    setCustomChainEndpointsForAccountCluster(accountClusterId: string, chainEndpoints: ChainEndpoint[]): Promise<boolean>;
+    removeCustomChainEndpointsForAccountCluster(accountClusterId: string, chainIds: bigint[]): Promise<boolean>;
+    getCustomChainEndpointsForAccountCluster(accountClusterId: string, returnChainIdsOnly: boolean): Promise<ChainEndpoint[]>;
+    isChainSupportedOnAccountCluster(accountClusterId: string, chainId: bigint): Promise<ChainSupportStatus>;
+    getNodeRpcUrl(accountClusterId: string, chainId: bigint): Promise<string>;
+    getVirtualNodeRpcUrl(accountClusterId: string, chainId: bigint, entrypointAccountAddress: string): Promise<string>;
+    getActivity(accountClusterId: string, limit?: number, offset?: number, order?: Order, startDate?: number, endDate?: number, filters?: {
+        transactionHash?: string;
+        address?: string;
+    }[]): Promise<{
+        activities: Activity[];
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalCount: number;
+        };
+    }>;
+    getPortfolioOverview(accountClusterId: string): Promise<FungibleTokenOverview>;
+    getFungibleTokenPortfolio(accountClusterId: string): Promise<StandardizedBalance[]>;
+    getFungibleTokenBalances(accountClusterId: string, offset?: number, limit?: number, chainId?: bigint, tokensToOmit?: string[]): Promise<StandardizedBalance[]>;
+}

package/dist/cjs/interfaces/account_cluster.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });