@ember-finance/sdk 0.0.1

package/dist/src/vaults/on-chain-calls/user.d.ts

@@ -0,0 +1,47 @@
+import { OnChainCalls } from "./onchain-calls";
+import { IDeployment, IVaultOptionalParams } from "../interfaces";
+import { OnChainCallResponse, Signer, SuiAddress, SuiClient, SuiTransactionBlockResponseOptions, NumStr } from "@firefly-exchange/library-sui";
+export declare class UserCalls extends OnChainCalls {
+    constructor(_network: string, _suiClient: SuiClient, _deployment: IDeployment, _signer?: Signer, _walletAddress?: string, _isUIWallet?: boolean);
+    /**
+     * Deposit asset into a vault
+     * @param vaultId The id of the vault to deposit into
+     * @param amount The amount of asset to deposit
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    depositAsset(vaultId: string, amount: NumStr, options?: IVaultOptionalParams & {
+        coinId?: string;
+    } & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Mint shares of a vault
+     * @param vaultId The id of the vault to mint shares for
+     * @param numberOfShares The number of shares to mint
+     * @param coinId The id of the coin used to mint shares
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    mintShares(vaultId: string, numberOfShares: NumStr, options?: IVaultOptionalParams & {
+        receiver?: SuiAddress;
+        coinId?: string;
+    } & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Redeem shares of a vault
+     * @param vaultId The id of the vault to redeem shares from
+     * @param amountOfShares The number of shares to redeem
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    redeemShares(vaultId: string, amountOfShares: NumStr, options?: IVaultOptionalParams & {
+        receiver?: SuiAddress;
+        coinId?: string;
+    } & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Cancel pending withdrawal request
+     * @param vaultId The id of the vault to cancel the pending withdrawal request from
+     * @param sequenceNumber The sequence number of the withdrawal request to cancel
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    cancelPendingWithdrawalRequest(vaultId: string, sequenceNumber: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+}

package/dist/src/vaults/on-chain-calls/user.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserCalls = void 0;
+const onchain_calls_1 = require("./onchain-calls");
+const library_sui_1 = require("@firefly-exchange/library-sui");
+const vault_1 = require("./vault");
+class UserCalls extends onchain_calls_1.OnChainCalls {
+    constructor(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet) {
+        super(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet);
+    }
+    /**
+     * Deposit asset into a vault
+     * @param vaultId The id of the vault to deposit into
+     * @param amount The amount of asset to deposit
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async depositAsset(vaultId, amount, options) {
+        let coinId = options?.coinId;
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        let split;
+        let merged;
+        if (!coinId) {
+            const coinType = this.parser.getDepositCoinType(vaultId);
+            [split, merged] = await library_sui_1.CoinUtils.createCoinWithBalance(this.suiClient, txb, (0, library_sui_1.bigNumber)(amount).toFixed(0), coinType, this.walletAddress);
+            coinId = split;
+        }
+        else {
+            [split, merged] = await library_sui_1.CoinUtils.validateCoinBalance(this.suiClient, txb, (0, library_sui_1.bigNumber)(amount).toFixed(0), coinId);
+            coinId = split;
+        }
+        this.txBuilder.depositAsset(vaultId, coinId, { ...options, txBlock: txb });
+        if (merged) {
+            txb.transferObjects([merged], this.walletAddress);
+        }
+        return this.execCall(txb, options);
+    }
+    /**
+     * Mint shares of a vault
+     * @param vaultId The id of the vault to mint shares for
+     * @param numberOfShares The number of shares to mint
+     * @param coinId The id of the coin used to mint shares
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async mintShares(vaultId, numberOfShares, options) {
+        let coinId = options?.coinId;
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        const vaultRate = await vault_1.Vault.getVaultRate(this.suiClient, vaultId);
+        const vaultRateBN = (0, library_sui_1.bigNumber)(vaultRate).shiftedBy(library_sui_1.SUI_NATIVE_BASE);
+        const assetAmountRequired = (0, library_sui_1.bigNumber)(numberOfShares)
+            .multipliedBy(vaultRateBN)
+            .toFixed(0);
+        let split;
+        let merged;
+        if (!coinId) {
+            const coinType = this.parser.getDepositCoinType(vaultId);
+            [split, merged] = await library_sui_1.CoinUtils.createCoinWithBalance(this.suiClient, txb, assetAmountRequired, coinType, this.walletAddress);
+            coinId = split;
+        }
+        else {
+            [split, merged] = await library_sui_1.CoinUtils.validateCoinBalance(this.suiClient, txb, assetAmountRequired, coinId);
+            coinId = split;
+        }
+        this.txBuilder.mintShares(vaultId, coinId, numberOfShares, options?.receiver || this.walletAddress, { ...options, txBlock: txb });
+        if (merged) {
+            txb.transferObjects([merged], this.walletAddress);
+        }
+        return this.execCall(txb, options);
+    }
+    /**
+     * Redeem shares of a vault
+     * @param vaultId The id of the vault to redeem shares from
+     * @param amountOfShares The number of shares to redeem
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async redeemShares(vaultId, amountOfShares, options) {
+        let coinId = options?.coinId;
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        let merged;
+        let split;
+        if (!coinId) {
+            const coinType = this.parser.getReceiptCoinType(vaultId);
+            [split, merged] = await library_sui_1.CoinUtils.createCoinWithBalance(this.suiClient, txb, (0, library_sui_1.bigNumber)(amountOfShares).toFixed(0), coinType, this.walletAddress);
+            coinId = split;
+        }
+        else {
+            [split, merged] = await library_sui_1.CoinUtils.validateCoinBalance(this.suiClient, txb, (0, library_sui_1.bigNumber)(amountOfShares).toFixed(0), coinId);
+            coinId = split;
+        }
+        this.txBuilder.redeemShares(vaultId, coinId, options?.receiver || this.walletAddress, { ...options, txBlock: txb });
+        if (merged) {
+            txb.transferObjects([merged], this.walletAddress);
+        }
+        return this.execCall(txb, options);
+    }
+    /**
+     * Cancel pending withdrawal request
+     * @param vaultId The id of the vault to cancel the pending withdrawal request from
+     * @param sequenceNumber The sequence number of the withdrawal request to cancel
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async cancelPendingWithdrawalRequest(vaultId, sequenceNumber, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.cancelPendingWithdrawalRequest(vaultId, sequenceNumber, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+}
+exports.UserCalls = UserCalls;

package/dist/src/vaults/on-chain-calls/vault-admin.d.ts

@@ -0,0 +1,64 @@
+import { OnChainCalls } from "./onchain-calls";
+import { IDeployment, IVaultOptionalParams } from "../interfaces";
+import { NumStr } from "@firefly-exchange/library-sui";
+import { OnChainCallResponse, Signer, SuiClient, SuiTransactionBlockResponseOptions } from "@firefly-exchange/library-sui";
+export declare class VaultAdminCalls extends OnChainCalls {
+    constructor(_network: string, _suiClient: SuiClient, _deployment: IDeployment, _signer?: Signer, _walletAddress?: string);
+    /**
+     * Set min withdrawal shares
+     * @param vaultId The id of the vault to set the min withdrawal shares for
+     * @param minWithdrawalShares The minimum number of shares to withdraw
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    setMinWithdrawalShares(vaultId: string, minWithdrawalShares: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update vault fee percentage
+     * @param vaultId The id of the vault to update the fee percentage for
+     * @param feePercentage The new fee percentage to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    updateVaultFeePercentage(vaultId: string, feePercentage: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Set/unset sub account
+     * @param vaultId The id of the vault to set the sub account for
+     * @param subAccount The sub account to set for the vault
+     * @param isSubAccount Whether the sub account is a sub account
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    setSubAccount(vaultId: string, subAccount: string, isSubAccount: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update vault operator
+     * @param vaultId The id of the vault to update the operator for
+     * @param operator The operator to update for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    updateVaultOperator(vaultId: string, operator: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update vault paused status
+     * @param vaultId The id of the vault to update the paused status for
+     * @param paused The new paused status to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    updateVaultPausedStatus(vaultId: string, paused: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update vault rate update interval
+     * @param vaultId The id of the vault to update the rate update interval for
+     * @param rateUpdateInterval The new rate update interval to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    updateVaultRateUpdateInterval(vaultId: string, rateUpdateInterval: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update vault max TVL
+     * @param vaultId The id of the vault to update the max TVL for
+     * @param maxTVL The new max TVL to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    updateVaultMaxTVL(vaultId: string, maxTVL: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+}

package/dist/src/vaults/on-chain-calls/vault-admin.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultAdminCalls = void 0;
+const onchain_calls_1 = require("./onchain-calls");
+const library_sui_1 = require("@firefly-exchange/library-sui");
+class VaultAdminCalls extends onchain_calls_1.OnChainCalls {
+    constructor(_network, _suiClient, _deployment, _signer, _walletAddress) {
+        super(_network, _suiClient, _deployment, _signer, _walletAddress);
+    }
+    /**
+     * Set min withdrawal shares
+     * @param vaultId The id of the vault to set the min withdrawal shares for
+     * @param minWithdrawalShares The minimum number of shares to withdraw
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async setMinWithdrawalShares(vaultId, minWithdrawalShares, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.setMinWithdrawalShares(vaultId, minWithdrawalShares, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update vault fee percentage
+     * @param vaultId The id of the vault to update the fee percentage for
+     * @param feePercentage The new fee percentage to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultFeePercentage(vaultId, feePercentage, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultFeePercentage(vaultId, feePercentage, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Set/unset sub account
+     * @param vaultId The id of the vault to set the sub account for
+     * @param subAccount The sub account to set for the vault
+     * @param isSubAccount Whether the sub account is a sub account
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async setSubAccount(vaultId, subAccount, isSubAccount, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.setSubAccount(vaultId, subAccount, isSubAccount, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update vault operator
+     * @param vaultId The id of the vault to update the operator for
+     * @param operator The operator to update for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultOperator(vaultId, operator, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultOperator(vaultId, operator, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update vault paused status
+     * @param vaultId The id of the vault to update the paused status for
+     * @param paused The new paused status to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultPausedStatus(vaultId, paused, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultPausedStatus(vaultId, paused, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update vault rate update interval
+     * @param vaultId The id of the vault to update the rate update interval for
+     * @param rateUpdateInterval The new rate update interval to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultRateUpdateInterval(vaultId, rateUpdateInterval, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultRateUpdateInterval(vaultId, rateUpdateInterval, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update vault max TVL
+     * @param vaultId The id of the vault to update the max TVL for
+     * @param maxTVL The new max TVL to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultMaxTVL(vaultId, maxTVL, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultMaxTVL(vaultId, maxTVL, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+}
+exports.VaultAdminCalls = VaultAdminCalls;

package/dist/src/vaults/on-chain-calls/vault.d.ts

@@ -0,0 +1,42 @@
+import { Signer, SuiClient } from "@firefly-exchange/library-sui";
+import { IVaultAccount } from "../interfaces";
+export declare class Vault {
+    /**
+     * Fetches the vault rate from on-chain
+     * @param suiClient Sui Client
+     * @param vaultId The id of the vault to fetch the rate for
+     * @returns The vault rate
+     */
+    static getVaultRate(suiClient: SuiClient, vaultId: string): Promise<number>;
+    static getPendingWithdrawalRequests(suiClient: SuiClient, vaultId: string, walletAddress: string): Promise<IVaultAccount>;
+    static signUpdateVaultStrategyRequest(payload: {
+        vaultId: string;
+        strategies: {
+            platformName: string;
+            strategistAddress: string;
+            strategyType: string;
+            allocationE9: string;
+            apyE9: string;
+            pointsApyE9: string;
+            snapshotAt: number;
+        }[];
+        targetApyE9: string;
+    }, signer: Signer): Promise<{
+        bcsPayload: string;
+        requestBody: {
+            vaultId: string;
+            strategies: {
+                platformName: string;
+                strategistAddress: string;
+                strategyType: string;
+                allocationE9: string;
+                apyE9: string;
+                pointsApyE9: string;
+                snapshotAt: number;
+            }[];
+            targetApyE9: string;
+            signedAt: number;
+            signature: string;
+        };
+    }>;
+}

package/dist/src/vaults/on-chain-calls/vault.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vault = void 0;
+const bcs_1 = require("../interfaces/bcs");
+class Vault {
+    /**
+     * Fetches the vault rate from on-chain
+     * @param suiClient Sui Client
+     * @param vaultId The id of the vault to fetch the rate for
+     * @returns The vault rate
+     */
+    static async getVaultRate(suiClient, vaultId) {
+        const response = await suiClient.getObject({
+            id: vaultId,
+            options: {
+                showContent: true
+            }
+        });
+        return (response.data?.content).fields?.["rate"]?.fields?.["value"];
+    }
+    static async getPendingWithdrawalRequests(suiClient, vaultId, walletAddress) {
+        const objDetails = await suiClient.getObject({
+            id: vaultId,
+            options: { showContent: true }
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const userTable = (objDetails.data?.content).fields.accounts.fields.id.id;
+        try {
+            const userData = await suiClient.getDynamicFieldObject({
+                parentId: userTable,
+                name: {
+                    type: "address",
+                    value: walletAddress
+                }
+            });
+            // parse the account
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const fields = (userData.data?.content).fields.value.fields;
+            const cancellationPendingWithdrawalRequestsSequenceNumbers = fields.cancel_withdraw_request;
+            return {
+                cancellation_pending_withdrawal_requests: fields.pending_withdrawal_requests
+                    .filter((request) => cancellationPendingWithdrawalRequestsSequenceNumbers.includes(request.fields.sequence_number))
+                    .map((request) => request.fields),
+                pending_withdrawal_requests: fields.pending_withdrawal_requests
+                    .filter((request) => !cancellationPendingWithdrawalRequestsSequenceNumbers.includes(request.fields.sequence_number))
+                    .map((request) => request.fields),
+                total_pending_withdrawal_shares: fields.total_pending_withdrawal_shares.toString()
+            };
+        }
+        catch (e) {
+            return {
+                cancellation_pending_withdrawal_requests: [],
+                pending_withdrawal_requests: [],
+                total_pending_withdrawal_shares: "0"
+            };
+        }
+    }
+    static async signUpdateVaultStrategyRequest(payload, signer) {
+        const now = Date.now();
+        const bcsPayload = bcs_1.BcsUpdateVaultStrategyRequest.serialize({
+            vaultId: payload.vaultId,
+            strategies: payload.strategies,
+            targetApyE9: payload.targetApyE9,
+            signedAt: now
+        }).toBytes();
+        const { signature, bytes } = await signer.signPersonalMessage(bcsPayload);
+        return {
+            bcsPayload: bytes,
+            requestBody: {
+                vaultId: payload.vaultId,
+                strategies: payload.strategies,
+                signedAt: now,
+                targetApyE9: payload.targetApyE9,
+                signature: signature
+            }
+        };
+    }
+}
+exports.Vault = Vault;

package/dist/src/vaults/utils/common.d.ts

@@ -0,0 +1,2 @@
+import { SuiClient, TransactionBlock } from "@firefly-exchange/library-sui";
+export declare const getTxBytes: (tx: TransactionBlock, client: SuiClient) => Promise<string>;

package/dist/src/vaults/utils/common.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTxBytes = void 0;
+const utils_1 = require("@mysten/sui/utils");
+const getTxBytes = async (tx, client) => {
+    return (0, utils_1.toBase64)(await tx.build({ client: client, onlyTransactionKind: false }));
+};
+exports.getTxBytes = getTxBytes;

package/dist/src/vaults/utils/deployment-parser.d.ts

@@ -0,0 +1,13 @@
+import { IDeployment } from "../interfaces";
+export declare class DeploymentParser {
+    deployment: IDeployment;
+    constructor(_deployment: IDeployment);
+    getAdminCap(): string;
+    getPackageId(): string;
+    getUpgradeCap(): string;
+    getProtocolConfig(): string;
+    getReceiptCoinTreasuryCap(receiptCoinType: string): string;
+    getDepositCoinType(vaultId: string): string;
+    getReceiptCoinType(vaultId: string): string;
+    getDepositCoinDecimals(vaultId: string): number;
+}

package/dist/src/vaults/utils/deployment-parser.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentParser = void 0;
+class DeploymentParser {
+    constructor(_deployment) {
+        this.deployment = _deployment;
+    }
+    getAdminCap() {
+        return this.deployment.VaultProtocol.AdminCap;
+    }
+    getPackageId() {
+        return this.deployment.VaultProtocol.Package;
+    }
+    getUpgradeCap() {
+        return this.deployment.VaultProtocol.UpgradeCap;
+    }
+    getProtocolConfig() {
+        return this.deployment.VaultProtocol.ProtocolConfig;
+    }
+    getReceiptCoinTreasuryCap(receiptCoinType) {
+        const treasuryCap = this.deployment.UltraCoins.find(coin => coin.Currency === receiptCoinType)?.TreasuryCap;
+        if (!treasuryCap) {
+            throw new Error(`Treasury cap not found for receipt coin type: ${receiptCoinType}`);
+        }
+        return treasuryCap;
+    }
+    getDepositCoinType(vaultId) {
+        const vault = Object.values(this.deployment.Vaults).find(vault => vault.ObjectId === vaultId);
+        if (!vault) {
+            throw new Error(`Vault not found for id: ${vaultId}`);
+        }
+        return vault.DepositCoinType;
+    }
+    getReceiptCoinType(vaultId) {
+        const vault = Object.values(this.deployment.Vaults).find(vault => vault.ObjectId === vaultId);
+        if (!vault) {
+            throw new Error(`Vault not found for id: ${vaultId}`);
+        }
+        return vault.ReceiptCoinType;
+    }
+    getDepositCoinDecimals(vaultId) {
+        const vault = Object.values(this.deployment.Vaults).find(vault => vault.ObjectId === vaultId);
+        if (!vault) {
+            throw new Error(`Vault not found for id: ${vaultId}`);
+        }
+        return vault.DepositCoinDecimals;
+    }
+}
+exports.DeploymentParser = DeploymentParser;

package/dist/src/vaults/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./deployment-parser";
+export * from "./common";

package/dist/src/vaults/utils/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./deployment-parser"), exports);
+__exportStar(require("./common"), exports);

package/package.json

@@ -0,0 +1,79 @@
+{
+    "name": "@ember-finance/sdk",
+    "description": "Ember Protocol SDK",
+    "version": "0.0.1",
+    "module": "./dist/index.js",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "sideEffects": false,
+    "react-native": {
+        "fs": false
+    },
+    "browser": {
+        "fs": false
+    },
+    "exports": {
+        "./vaults": {
+            "types": "./dist/src/vaults/index.d.ts",
+            "import": "./dist/src/vaults/index.js",
+            "require": "./dist/src/vaults/index.js"
+        }
+    },
+    "scripts": {
+        "build": "yarn run clean && tsc",
+        "clean": "rm -rf dist",
+        "prepare": "husky install",
+        "lint": "yarn eslint --fix --cache --max-warnings=-1 .",
+        "format-all": "yarn prettier --write .",
+        "format-staged": "git-format-staged -f \"prettier '{}'\" '**/*.js' '**/*.json' '**/*.ts' ",
+        "ci:code-formatting": "yarn prettier --check .",
+        "ci:code-style": "yarn eslint .",
+        "setup:sui": "docker-compose -f local/sui/docker-compose.yml up -d",
+        "teardown:sui": "docker-compose -f  local/sui/docker-compose.yml down",
+        "test": "ts-mocha --no-timeout tests/*.test.ts",
+        "publish-beta": "npm publish --tag beta"
+    },
+    "directories": {
+        "test": "tests"
+    },
+    "dependencies": {
+        "@firefly-exchange/library-sui": "^2.8.22",
+        "yargs": "^17.6.2",
+        "yarn": "^1.22.19"
+    },
+    "devDependencies": {
+        "@types/chai": "^4.3.3",
+        "@types/chai-as-promised": "^7.1.5",
+        "@types/dotenv-parse-variables": "^2.0.1",
+        "@types/expect": "^24.3.0",
+        "@types/lodash": "^4.14.195",
+        "@types/mocha": "^10.0.0",
+        "@typescript-eslint/eslint-plugin": "^5.0.0",
+        "chai": "^4.3.6",
+        "eslint": "^8.42.0",
+        "eslint-config-standard-with-typescript": "^34.0.0",
+        "eslint-plugin-import": "^2.25.2",
+        "eslint-plugin-n": "^15.0.0",
+        "eslint-plugin-promise": "^6.0.0",
+        "git-format-staged": "^3.0.0",
+        "husky": "^8.0.0",
+        "mocha": "^10.1.0",
+        "prettier": "^2.8.8",
+        "pretty-quick": "^3.1.3",
+        "ts-mocha": "^10.0.0",
+        "ts-node": "^10.9.1",
+        "typescript": "*"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fireflyprotocol/ember-sdk.git"
+    },
+    "author": "",
+    "license": "ISC",
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist"
+    ]
+}