@ember-finance/sdk 0.0.1

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminCalls = void 0;
+const onchain_calls_1 = require("./onchain-calls");
+const library_sui_1 = require("@firefly-exchange/library-sui");
+class AdminCalls extends onchain_calls_1.OnChainCalls {
+    constructor(_network, _suiClient, _deployment, _signer, _walletAddress) {
+        super(_network, _suiClient, _deployment, _signer, _walletAddress);
+    }
+    /**
+     * Create and executes create vault transaction. Allows admin to create a new vault on
+     * the protocol
+     * @param depositCoinType The type of the deposit coin
+     * @param receiptCoinType The type of the receipt coin
+     * @param vaultName Name of the vault
+     * @param adminAddress The admin address of the vault
+     * @param operatorAddress The operator address of the vault
+     * @param maxRateChangePerUpdate The maximum rate change per update
+     * @param feePercentage The fee percentage
+     * @param minWithdrawalShares The minimum withdrawal shares
+     * @param rateUpdateInterval The rate update interval
+     * @param maxTVL The maximum TVL of the vault
+     * @param subAccounts The sub accounts of the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async createVault(depositCoinType, receiptCoinType, vaultName, adminAddress, operatorAddress, maxRateChangePerUpdate, feePercentage, minWithdrawalShares, rateUpdateInterval, maxTVL, subAccounts, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.createVault(depositCoinType, receiptCoinType, vaultName, adminAddress, operatorAddress, maxRateChangePerUpdate, feePercentage, minWithdrawalShares, rateUpdateInterval, maxTVL, subAccounts, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the admin address of a vault
+     * @param vaultId The id of the vault
+     * @param adminAddress The new admin address
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultAdmin(vaultId, adminAddress, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultAdmin(vaultId, adminAddress, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the max fee percentage of the protocol
+     * @param maxFeePercentage The new max fee percentage
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateMaxFeePercentage(maxFeePercentage, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateMaxFeePercentage(maxFeePercentage, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the default rate of the protocol
+     * @param defaultRate The new default rate
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateDefaultRate(defaultRate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateDefaultRate(defaultRate, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the max rate of the protocol
+     * @param maxRate The new max rate
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateMaxRate(maxRate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateMaxRate(maxRate, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the min rate of the protocol
+     * @param minRate The new min rate
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateMinRate(minRate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateMinRate(minRate, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the platform fee recipient of the protocol
+     * @param platformFeeRecipient The new platform fee recipient
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updatePlatformFeeRecipient(platformFeeRecipient, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updatePlatformFeeRecipient(platformFeeRecipient, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Pause non admin operations
+     * @param pause Whether to pause non admin operations
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async pauseNonAdminOperations(pause, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.pauseNonAdminOperations(pause, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Increase the protocol version
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async increaseProtocolVersion(options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.increaseProtocolVersion({ ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update the max rate interval of the protocol
+     * @param maxRateInterval The new max rate interval
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateMaxRateInterval(maxRateInterval, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateMaxRateInterval(maxRateInterval, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+}
+exports.AdminCalls = AdminCalls;

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

@@ -0,0 +1,6 @@
+export * from "./admin";
+export * from "./tx-builder";
+export * from "./user";
+export * from "./vault-admin";
+export * from "./operator";
+export * from "./vault";

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

@@ -0,0 +1,22 @@
+"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("./admin"), exports);
+__exportStar(require("./tx-builder"), exports);
+__exportStar(require("./user"), exports);
+__exportStar(require("./vault-admin"), exports);
+__exportStar(require("./operator"), exports);
+__exportStar(require("./vault"), exports);

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

@@ -0,0 +1,34 @@
+import { DryRunTransactionBlockResponse, OnChainCallResponse, Signer, SuiClient, SuiTransactionBlockResponse, SuiTransactionBlockResponseOptions, TransactionBlock } from "@firefly-exchange/library-sui";
+import { Address } from "@firefly-exchange/library-sui";
+import { DeploymentParser } from "../utils/deployment-parser";
+import { IDeployment, IVaultOptionalParams } from "../interfaces";
+import { TxBuilder } from "./tx-builder";
+export declare class OnChainCalls {
+    suiClient: SuiClient;
+    signer: Signer;
+    parser: DeploymentParser;
+    walletAddress: string;
+    txBuilder: TxBuilder;
+    network: string;
+    isUIWallet: boolean;
+    constructor(_network: string, _suiClient: SuiClient, _deployment: IDeployment, _signer?: Signer, _walletAddress?: Address, _isUIWallet?: boolean);
+    /**
+     * Signs and executes the given transaction block
+     * @param txBlock Sui transaction block
+     * @returns Sui Transaction Block Response
+     */
+    signAndExecuteTxBlock(txBlock: TransactionBlock, options?: SuiTransactionBlockResponseOptions): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Signs and executes the given transaction block
+     * @param txBlock Sui transaction block
+     * @returns Sui Transaction Block Response
+     */
+    dryRunTxBlock(txBlock: TransactionBlock): Promise<DryRunTransactionBlockResponse>;
+    /**
+     *  Dry runs or executes the call on chain depending on the params
+     * @param dryRun True if dry run is to be performed
+     * @param txBlock The transaction block
+     * @returns
+     */
+    execCall(txBlock: TransactionBlock, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnChainCalls = void 0;
+const library_sui_1 = require("@firefly-exchange/library-sui");
+const deployment_parser_1 = require("../utils/deployment-parser");
+const tx_builder_1 = require("./tx-builder");
+class OnChainCalls {
+    constructor(_network, _suiClient, _deployment, _signer, _walletAddress, _isUIWallet) {
+        this.network = _network;
+        this.suiClient = _suiClient;
+        this.parser = new deployment_parser_1.DeploymentParser(_deployment);
+        // could be undefined, if initializing the bluefinVaults for only get calls
+        this.signer = _signer;
+        this.walletAddress = _walletAddress || _signer?.toSuiAddress();
+        this.txBuilder = new tx_builder_1.TxBuilder(_deployment);
+        this.isUIWallet = _isUIWallet || false;
+    }
+    /**
+     * Signs and executes the given transaction block
+     * @param txBlock Sui transaction block
+     * @returns Sui Transaction Block Response
+     */
+    async signAndExecuteTxBlock(txBlock, options) {
+        return library_sui_1.SuiBlocks.signAndExecuteTxBlock(txBlock, this.suiClient, this.signer, this.isUIWallet, options);
+    }
+    /**
+     * Signs and executes the given transaction block
+     * @param txBlock Sui transaction block
+     * @returns Sui Transaction Block Response
+     */
+    async dryRunTxBlock(txBlock) {
+        return library_sui_1.SuiBlocks.dryRunTxBlock(txBlock, this.suiClient, this.signer, this.isUIWallet);
+    }
+    /**
+     *  Dry runs or executes the call on chain depending on the params
+     * @param dryRun True if dry run is to be performed
+     * @param txBlock The transaction block
+     * @returns
+     */
+    async execCall(txBlock, options) {
+        if (options?.dryRun) {
+            return this.dryRunTxBlock(txBlock);
+        }
+        else if (options?.returnTxb) {
+            return txBlock;
+        }
+        else {
+            const response = await this.signAndExecuteTxBlock(txBlock, options);
+            return response;
+        }
+    }
+}
+exports.OnChainCalls = OnChainCalls;

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

@@ -0,0 +1,74 @@
+import { OnChainCalls } from "./onchain-calls";
+import { IDeployment, IVaultOptionalParams } from "../interfaces";
+import { OnChainCallResponse, Signer, SuiClient, SuiTransactionBlockResponseOptions } from "@firefly-exchange/library-sui";
+import { NumStr } from "@firefly-exchange/library-sui";
+export declare class OperatorCalls extends OnChainCalls {
+    constructor(_network: string, _suiClient: SuiClient, _deployment: IDeployment, _signer?: Signer, _walletAddress?: string);
+    /**
+     * Collect platform fee from a vault
+     * @param vaultId The id of the vault to collect platform fee from
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    collectPlatformFee(vaultId: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Charge platform fee from a vault
+     * @param vaultId The id of the vault to charge platform fee from
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    chargePlatformFee(vaultId: string, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Process withdrawal requests up to a timestamp
+     * @param vaultId The id of the vault to process withdrawal requests for
+     * @param timestamp The timestamp to process withdrawal requests up to
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    processWithdrawalRequestsUpToTimestamp(vaultId: string, timestamp: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Process withdrawal requests upto max request count
+     * @param vaultId The id of the vault to process withdrawal requests for
+     * @param maxRequestCount The maximum number of withdrawal requests to process
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    processWithdrawalRequests(vaultId: string, maxRequestCount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Withdraw from vault without redeeming shares
+     * @param vaultId The id of the vault to withdraw from
+     * @param subAccount The sub account to withdraw to
+     * @param amount The amount to withdraw
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    withdrawFromVaultWithoutRedeemingShares(vaultId: string, subAccount: string, amount: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Deposit to vault without minting shares
+     * @param vaultId The id of the vault to deposit to
+     * @param subAccount The sub account to deposit from
+     * @param amount The amount to deposit
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    depositToVaultWithoutMintingShares(vaultId: string, subAccount: string, amount: NumStr, options?: IVaultOptionalParams & {
+        coinId?: string;
+    } & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Update vault rate
+     * @param vaultId The id of the vault to update the rate for
+     * @param rate The new rate to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    updateVaultRate(vaultId: string, rate: NumStr, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+    /**
+     * Set blacklisted account
+     * @param vaultId The id of the vault to set the blacklisted account for
+     * @param account The account to set as blacklisted
+     * @param isBlacklisted Whether the account should be blacklisted
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    setBlacklistedAccount(vaultId: string, account: string, isBlacklisted: boolean, options?: IVaultOptionalParams & SuiTransactionBlockResponseOptions): Promise<OnChainCallResponse>;
+}

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorCalls = void 0;
+const onchain_calls_1 = require("./onchain-calls");
+const library_sui_1 = require("@firefly-exchange/library-sui");
+const library_sui_2 = require("@firefly-exchange/library-sui");
+class OperatorCalls extends onchain_calls_1.OnChainCalls {
+    constructor(_network, _suiClient, _deployment, _signer, _walletAddress) {
+        super(_network, _suiClient, _deployment, _signer, _walletAddress);
+    }
+    /**
+     * Collect platform fee from a vault
+     * @param vaultId The id of the vault to collect platform fee from
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async collectPlatformFee(vaultId, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.collectPlatformFee(vaultId, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Charge platform fee from a vault
+     * @param vaultId The id of the vault to charge platform fee from
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async chargePlatformFee(vaultId, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.chargePlatformFee(vaultId, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Process withdrawal requests up to a timestamp
+     * @param vaultId The id of the vault to process withdrawal requests for
+     * @param timestamp The timestamp to process withdrawal requests up to
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async processWithdrawalRequestsUpToTimestamp(vaultId, timestamp, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.processWithdrawalRequestsUpToTimestamp(vaultId, timestamp, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Process withdrawal requests upto max request count
+     * @param vaultId The id of the vault to process withdrawal requests for
+     * @param maxRequestCount The maximum number of withdrawal requests to process
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async processWithdrawalRequests(vaultId, maxRequestCount, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.processWithdrawalRequests(vaultId, maxRequestCount, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Withdraw from vault without redeeming shares
+     * @param vaultId The id of the vault to withdraw from
+     * @param subAccount The sub account to withdraw to
+     * @param amount The amount to withdraw
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async withdrawFromVaultWithoutRedeemingShares(vaultId, subAccount, amount, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.withdrawFromVaultWithoutRedeemingShares(vaultId, subAccount, amount, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Deposit to vault without minting shares
+     * @param vaultId The id of the vault to deposit to
+     * @param subAccount The sub account to deposit from
+     * @param amount The amount to deposit
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async depositToVaultWithoutMintingShares(vaultId, subAccount, amount, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        let coinId = options?.coinId;
+        let split;
+        let merged;
+        if (!coinId) {
+            const coinType = this.parser.getDepositCoinType(vaultId);
+            [split, merged] = await library_sui_2.CoinUtils.createCoinWithBalance(this.suiClient, txb, amount, coinType, this.walletAddress);
+            coinId = split;
+        }
+        else {
+            [split, merged] = await library_sui_2.CoinUtils.validateCoinBalance(this.suiClient, txb, amount, coinId);
+            coinId = split;
+        }
+        this.txBuilder.depositToVaultWithoutMintingShares(vaultId, subAccount, coinId, {
+            ...options,
+            txBlock: txb
+        });
+        if (merged) {
+            txb.transferObjects([merged], this.walletAddress);
+        }
+        return this.execCall(txb, options);
+    }
+    /**
+     * Update vault rate
+     * @param vaultId The id of the vault to update the rate for
+     * @param rate The new rate to set for the vault
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async updateVaultRate(vaultId, rate, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.updateVaultRate(vaultId, rate, { ...options, txBlock: txb });
+        return this.execCall(txb, options);
+    }
+    /**
+     * Set blacklisted account
+     * @param vaultId The id of the vault to set the blacklisted account for
+     * @param account The account to set as blacklisted
+     * @param isBlacklisted Whether the account should be blacklisted
+     * @param options Optional tx execution params
+     * @returns OnChainCallResponse
+     */
+    async setBlacklistedAccount(vaultId, account, isBlacklisted, options) {
+        const txb = options?.txBlock || new library_sui_1.TransactionBlock();
+        this.txBuilder.setBlacklistedAccount(vaultId, account, isBlacklisted, {
+            ...options,
+            txBlock: txb
+        });
+        return this.execCall(txb, options);
+    }
+}
+exports.OperatorCalls = OperatorCalls;