@7kprotocol/sdk-ts 3.6.1-beta.0 → 3.6.1-beta.2

package/dist/index.d.ts

@@ -0,0 +1,536 @@
+import { SourceDex, QuoteResponse } from '@bluefin-exchange/bluefin7k-aggregator-sdk';
+import { PreSwapLpChangeParams, RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { Protocol, AggregatorQuoter } from '@flowx-finance/sdk';
+import { GasCostSummary, SuiClient, GetTransactionBlockParams, SuiTransactionBlockResponse } from '@mysten/sui/client';
+import { SignatureWithBytes } from '@mysten/sui/cryptography';
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+
+/**
+ * Swap mode options
+ */
+type SwapMode = "exactIn" | "exactOut";
+/**
+ * Token information
+ */
+interface OkxTokenInfo {
+    /** Token contract address */
+    tokenContractAddress: string;
+    /** Token symbol (e.g., "USDC") */
+    tokenSymbol: string;
+    /** Token unit price in USD (may be null for special cases) */
+    tokenUnitPrice: string | null;
+    /** Decimal number defining smallest unit */
+    decimal: string;
+    /** Whether the token is a honeypot token */
+    isHoneyPot: boolean;
+    /** Token tax rate (0-1, where 0.01 = 1%) */
+    taxRate: string;
+}
+/**
+ * DEX Protocol information
+ */
+interface OkxDexProtocol {
+    /** Name of the liquidity protocol (e.g., "Uniswap V3") */
+    dexName: string;
+    /** Percentage of assets handled by the protocol */
+    percent: string;
+}
+/**
+ * Sub-router information
+ */
+interface OkxSubRouter {
+    /** Liquidity protocol used on the path */
+    dexProtocol: OkxDexProtocol;
+    /** Index of the from token */
+    fromTokenIndex: string;
+    /** Index of the to token */
+    toTokenIndex: string;
+    /** Information of token to be sold */
+    fromToken: OkxTokenInfo;
+    /** Information of token to be bought */
+    toToken: OkxTokenInfo;
+}
+/**
+ * Quote comparison information
+ */
+interface OkxQuoteCompare {
+    /** DEX name of the quote route */
+    dexName: string;
+    /** DEX logo of the quote route */
+    dexLogo: string;
+    /** Estimated network fee (USD) of the quote route */
+    tradeFee: string;
+    /** Received amount of the quote route */
+    amountOut: string;
+    /** Price impact percentage */
+    priceImpactPercentage: string;
+}
+/**
+ * Transaction data model
+ */
+interface OkxTransactionData {
+    /** Additional signing data (if required). When tips is specified, represents calldata of jito tips transfer */
+    signatureData?: string[];
+    /** User's wallet address */
+    from: string;
+    /** Estimated amount of the gas limit (increase by 50% for accurate data) */
+    gas: string;
+    /** Gas price in wei */
+    gasPrice?: string;
+    /** EIP-1559: Recommended priority cost of gas per unit */
+    maxPriorityFeePerGas?: string;
+    /** The contract address of OKX DEX router */
+    to: string;
+    /** The amount of native tokens (in wei) to be sent to the contract */
+    value: string;
+    /** The maximum amount of a token to spend when price reaches upper limit of slippage (applies to exactOut mode) */
+    maxSpendAmount?: string;
+    /** The minimum amount of a token to buy when price reaches upper limit of slippage */
+    minReceiveAmount: string;
+    /** Call data */
+    data: string;
+    /** Current transaction slippage value */
+    slippagePercent: string;
+}
+/**
+ * Router result data
+ */
+interface OkxRouterResult {
+    /** Unique identifier for the chain */
+    chainIndex: string;
+    /** Context slot (for Solana) */
+    contextSlot?: number;
+    /** Quote path data set - array of sub-routers */
+    dexRouterList: OkxSubRouter[];
+    /** Estimated gas consumption in smallest units (e.g., wei) */
+    estimateGasFee: string;
+    /** Information of token to be sold */
+    fromToken: OkxTokenInfo;
+    /** The input amount of a token to be sold */
+    fromTokenAmount: string;
+    /** Price impact percentage = (Received value – Paid value) / Paid value. Can be positive if received value exceeds paid value */
+    priceImpactPercent: string;
+    /** Router identifier */
+    router: string;
+    /** Swap mode: "exactIn" or "exactOut" */
+    swapMode: SwapMode;
+    /** Information of token to be bought */
+    toToken: OkxTokenInfo;
+    /** The resulting amount of a token to be bought */
+    toTokenAmount: string;
+    /** Estimated network fee (USD) of the quote route */
+    tradeFee: string;
+    /** Comparison of quote routes */
+    quoteCompareList?: OkxQuoteCompare[];
+}
+/**
+ * Swap API Response Data
+ */
+interface OkxSwapResponseData {
+    /** Quote path data */
+    routerResult: OkxRouterResult;
+    /** Contract data model */
+    tx: OkxTransactionData;
+}
+
+declare enum EProvider {
+    BLUEFIN7K = "bluefin7k",
+    CETUS = "cetus",
+    FLOWX = "flowx",
+    OKX = "okx"
+}
+type ProviderBaseOptions = {
+    api?: string;
+    apiKey?: string;
+    disabled?: boolean;
+};
+type Bluefin7kProviderOptions = ProviderBaseOptions & {
+    sources?: SourceDex[];
+    excludedPools?: string[];
+    targetPools?: string[];
+};
+type FlowxProviderOptions = ProviderBaseOptions & {
+    sources?: Protocol[];
+    excludePools?: string[];
+    excludeSources?: Protocol[];
+    maxHops?: number;
+    splitDistributionPercent?: number;
+};
+type CetusProviderOptions = ProviderBaseOptions & {
+    sources?: string[];
+    splitCount?: number;
+    splitAlgorithm?: string;
+    splitFactor?: number;
+    depth?: number;
+    liquidityChanges?: PreSwapLpChangeParams[];
+};
+type OkxProviderOptions = Required<Omit<ProviderBaseOptions, "api">> & {
+    api?: string;
+    secretKey: string;
+    apiPassphrase: string;
+    projectId: string;
+};
+interface MetaAgOptions {
+    /**If not specified, all providers will be used */
+    providers?: {
+        [EProvider.BLUEFIN7K]?: Bluefin7kProviderOptions;
+        [EProvider.FLOWX]?: FlowxProviderOptions;
+        [EProvider.CETUS]?: CetusProviderOptions;
+        [EProvider.OKX]?: OkxProviderOptions;
+    };
+    /**Mainnet Json Rpc url, if not specified, the default mainnet url will be used */
+    fullnodeUrl?: string;
+    /**Hermes Api url, if not specified, the default hermes api url will be used */
+    hermesApi?: string;
+    /**Address to receive commission, if not specified, the commission will not be used */
+    partner?: string;
+    /**@default 0 */
+    partnerCommissionBps?: number;
+    /**@default 100 */
+    slippageBps?: number;
+    /**
+     * Tip to support 7k
+     * @default 0 */
+    tipBps?: number;
+}
+interface MetaQuoteOptions {
+    coinTypeIn: string;
+    coinTypeOut: string;
+    amountIn: string;
+    /** Required for api-tx providers (ie: Okx) */
+    signer?: string;
+    /**
+     * Timeout for quote operation in milliseconds
+     * @default 2000ms
+     */
+    timeout?: number;
+}
+interface MetaSimulationOptions {
+    sender: string;
+    /**
+     * Timeout for simulation operation in milliseconds
+     * @default 2000ms
+     */
+    timeout?: number;
+    /** If specify, defer the simulation that could reduce the time to display quote result, you must update the quote via the id on callback
+     * else await all quote and simulation before return
+     */
+    onSimulated?: (payload: MetaQuote) => void;
+}
+interface MetaFastSwapOptions {
+    /** Quote object from the quote operation */
+    quote: MetaQuote;
+    /** Signer address (owner of `coinIn`) */
+    signer: string;
+    /** If true, use the gas coin for the swap
+     * @default true */
+    useGasCoin?: boolean;
+    /**
+     * Sign the transaction bytes
+     * @param txBytes - base64 transaction bytes
+     * @returns - signature with bytes
+     */
+    signTransaction: (txBytes: string) => Promise<SignatureWithBytes>;
+}
+interface MetaSwapOptions {
+    /** Quote object from the quote operation */
+    quote: MetaQuote;
+    /** Signer address (owner of `coinIn`) */
+    signer: string;
+    /** Transaction object to add the swap operation */
+    tx: Transaction;
+    /**
+     * Coin object used for the swap, must be consumed completely, no `coinIn` left, user must pass the coinIn object with the balance required for the swap - ie in quote `amountIn`
+     * @warning `coinIn` value must match the quote `amountIn` */
+    coinIn: TransactionObjectArgument;
+}
+type FlowxQuoteResponse = Awaited<ReturnType<AggregatorQuoter["getRoutes"]>>;
+type MetaQuote = ({
+    provider: EProvider.BLUEFIN7K;
+    quote: QuoteResponse;
+} | {
+    provider: EProvider.CETUS;
+    quote: RouterDataV3;
+} | {
+    provider: EProvider.FLOWX;
+    quote: FlowxQuoteResponse;
+} | {
+    provider: EProvider.OKX;
+    quote: OkxSwapResponseData;
+}) & {
+    /** uuid to keep track the quote result, used to apply simulation result on quote on callback `onSimulated`*/
+    id: string;
+    /** coin type: ie 0x2::sui::SUI */
+    coinTypeIn: string;
+    /** coin type: ie 0x2::sui::SUI */
+    coinTypeOut: string;
+    /** Amount in as u64 */
+    amountIn: string;
+    /** Amount out as u64 if there're no commission be applied to the amount out */
+    rawAmountOut: string;
+    /** Amount as u64 after minus any commission kind */
+    amountOut: string;
+    /** Simulated amount out if the transaction is executed */
+    simulatedAmountOut?: string;
+    /** Estimate gas consumption if the transaction is executed */
+    gasUsed?: GasCostSummary;
+};
+interface QuoteProvider {
+    readonly kind: EProvider;
+    quote(_quoteOptions: MetaQuoteOptions): Promise<MetaQuote | null>;
+}
+interface SwapAPIProvider extends QuoteProvider {
+    readonly kind: EProvider.OKX;
+    fastSwap(options: MetaFastSwapOptions): Promise<string>;
+}
+interface AggregatorProvider extends QuoteProvider {
+    readonly kind: EProvider.BLUEFIN7K | EProvider.CETUS | EProvider.FLOWX;
+    swap(options: MetaSwapOptions): Promise<TransactionObjectArgument>;
+}
+declare const isAggregatorProvider: (provider: QuoteProvider) => provider is AggregatorProvider;
+declare const isSwapAPIProvider: (provider: QuoteProvider) => provider is SwapAPIProvider;
+
+declare class MetaAg {
+    client: SuiClient;
+    private providers;
+    private inspector;
+    private options;
+    constructor(options?: MetaAgOptions);
+    private _getProvider;
+    private _simulate;
+    private _quote;
+    private _fastSwap;
+    /**
+     * Get quotes from all providers
+     * @param options - quote options
+     * @param simulation - if present, the quote will be simulated
+     * @returns quotes from all providers
+     */
+    quote(options: MetaQuoteOptions, simulation?: MetaSimulationOptions): Promise<MetaQuote[]>;
+    /**
+     * Build transaction from quote
+     * @info Use this function to build composable transaction (ie: add more commands after the swap, consume the coin out object)
+     * @warning Providers that build transaction on the fly (typically RFQ, Swap-API providers ie: Okx, ...) are not supported, please use `fastSwap` instead
+     * @param options - build tx options
+     * @param slippageBps - slippage bps if not specified, fallback to global slippage bps, if none of them specified, default to 100
+     * @returns coin out object, you must consume it by transferObjects, or other sub sequence commands
+     */
+    swap(options: MetaSwapOptions, slippageBps?: number): Promise<TransactionObjectArgument>;
+    /**
+     * Build, Sign, and Execute transaction in one step
+     * @param options - fast swap options
+     * @returns - txDigest of the transaction
+     */
+    fastSwap(options: MetaFastSwapOptions, getTransactionBlockParams?: Omit<GetTransactionBlockParams, "digest">): Promise<SuiTransactionBlockResponse>;
+    /**
+     * Update meta aggregator options
+     * @param options - update options payload
+     */
+    updateMetaAgOptions(options: MetaAgOptions): void;
+}
+
+/**
+ * Get price for a single token
+ * @param id - Token ID (coin type)
+ * @returns Token price, or 0 if not found or on error
+ */
+declare function getTokenPrice(id: string): Promise<number>;
+/**
+ * Get prices for multiple tokens
+ * @param ids - Array of token IDs (coin types)
+ * @returns Record mapping token IDs to their prices
+ */
+declare function getTokenPrices(ids: string[]): Promise<Record<string, number>>;
+/**
+ * Get the current SUI token price
+ * @returns SUI price, or 0 if not found or on error
+ */
+declare function getSuiPrice(): Promise<number>;
+
+interface PlaceLimitOrderParams {
+    accountAddress: string;
+    payCoinType: string;
+    targetCoinType: string;
+    payCoinAmount: bigint;
+    rate: bigint;
+    slippage: bigint;
+    expireTs: bigint;
+    devInspect?: boolean;
+}
+declare function placeLimitOrder({ accountAddress, payCoinType, targetCoinType, payCoinAmount, rate, slippage, expireTs, devInspect, }: PlaceLimitOrderParams): Promise<Transaction>;
+
+interface CancelLimitOrderParams {
+    orderId: string;
+    payCoinType: string;
+    targetCoinType: string;
+}
+declare function cancelLimitOrder({ orderId, payCoinType, targetCoinType, }: CancelLimitOrderParams): Promise<Transaction>;
+
+interface ClaimExpiredLimitOrderParams {
+    orderId: string;
+    payCoinType: string;
+    targetCoinType: string;
+}
+declare function claimExpiredLimitOrder({ orderId, payCoinType, targetCoinType, }: ClaimExpiredLimitOrderParams): Promise<Transaction>;
+
+declare enum LoDcaOrderStatus {
+    PENDING = "PENDING",
+    ACTIVE = "ACTIVE",
+    EXPIRED = "EXPIRED",
+    CANCELED = "CANCELED"
+}
+interface LimitOrder {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    softDeleteAt: string;
+    orderId: string;
+    owner: string;
+    payCoinName: string;
+    targetCoinName: string;
+    totalPayAmount: string;
+    paidAmount: string;
+    obtainedAmount: string;
+    claimedAmount: string;
+    targetBalance: string;
+    createdTs: number;
+    expireTs: number;
+    canceledTs: number;
+    lastExecutedTs: number;
+    status: LoDcaOrderStatus;
+    payBalance: string;
+    rate: string;
+    slippageBps: string;
+    filled: number;
+    volume: number;
+    digest: string | null;
+}
+interface DcaOrder {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    softDeletedAt: string;
+    orderId: string;
+    owner: string;
+    payCoinName: string;
+    targetCoinName: string;
+    totalPayAmount: string;
+    paidAmount: string;
+    obtainedAmount: string;
+    claimedAmount: string;
+    targetBalance: string;
+    createdTs: number;
+    expireTs: number;
+    canceledTs: number;
+    status: LoDcaOrderStatus;
+    slippage: number;
+    minRate: string;
+    maxRate: string;
+    amountPerOrder: string;
+    interval: number;
+    filled: number;
+    volume: number;
+    digest: string | null;
+    numOrders: number;
+}
+declare enum LoDcaOrderExecutionStatus {
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS",
+    FAILED = "FAILED"
+}
+interface LoDcaOrderExecution {
+    id: number;
+    createdAt: string;
+    updatedAt: string;
+    softDeletedAt: null;
+    orderId: string;
+    digest: string;
+    payCoinName: string;
+    targetCoinName: string;
+    payAmount: string;
+    repayAmount: string;
+    obtainedAmount: string;
+    executedTs: number;
+    slippage: number;
+    status: LoDcaOrderExecutionStatus;
+    orderType: string;
+    volume: number | null;
+}
+
+interface Params$4 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getOpenLimitOrders({ owner, offset, limit, tokenPair, }: Params$4): Promise<LimitOrder[]>;
+
+interface Params$3 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getClosedLimitOrders({ owner, offset, limit, tokenPair, }: Params$3): Promise<LimitOrder[]>;
+
+interface PlaceDcaOrderParams {
+    payCoinType: string;
+    targetCoinType: string;
+    payCoinAmountEach: bigint;
+    numOrders: number;
+    interval: number;
+    slippage: bigint;
+    minRate: bigint;
+    maxRate: bigint;
+}
+declare function placeDcaOrder({ payCoinType, targetCoinType, payCoinAmountEach, numOrders, interval, slippage, minRate, maxRate, }: PlaceDcaOrderParams): Promise<Transaction>;
+
+interface CancelDcaOrderParams {
+    orderId: string;
+    payCoinType: string;
+    targetCoinType: string;
+}
+declare function cancelDcaOrder({ orderId, payCoinType, targetCoinType, }: CancelDcaOrderParams): Promise<Transaction>;
+
+interface Params$2 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getOpenDcaOrders({ owner, offset, limit, tokenPair, }: Params$2): Promise<DcaOrder[]>;
+
+interface Params$1 {
+    owner: string;
+    offset: number;
+    limit: number;
+    tokenPair?: string;
+}
+declare function getClosedDcaOrders({ owner, offset, limit, tokenPair, }: Params$1): Promise<LoDcaOrderExecution[]>;
+
+interface Params {
+    owner: string;
+    orderId: string;
+    offset: number;
+    limit: number;
+}
+declare function getDcaOrderExecutions({ owner, orderId, offset, limit, }: Params): Promise<LoDcaOrderExecution[]>;
+
+declare const _default: {
+    getTokenPrice: typeof getTokenPrice;
+    getTokenPrices: typeof getTokenPrices;
+    getSuiPrice: typeof getSuiPrice;
+    placeLimitOrder: typeof placeLimitOrder;
+    getOpenLimitOrders: typeof getOpenLimitOrders;
+    cancelLimitOrder: typeof cancelLimitOrder;
+    claimExpiredLimitOrder: typeof claimExpiredLimitOrder;
+    getClosedLimitOrders: typeof getClosedLimitOrders;
+    placeDcaOrder: typeof placeDcaOrder;
+    getOpenDcaOrders: typeof getOpenDcaOrders;
+    cancelDcaOrder: typeof cancelDcaOrder;
+    getClosedDcaOrders: typeof getClosedDcaOrders;
+    getDcaOrderExecutions: typeof getDcaOrderExecutions;
+    MetaAg: typeof MetaAg;
+};
+
+export { type AggregatorProvider, type Bluefin7kProviderOptions, type CetusProviderOptions, EProvider, type FlowxProviderOptions, type FlowxQuoteResponse, MetaAg, type MetaAgOptions, type MetaFastSwapOptions, type MetaQuote, type MetaQuoteOptions, type MetaSimulationOptions, type MetaSwapOptions, type OkxProviderOptions, type QuoteProvider, type SwapAPIProvider, cancelDcaOrder, cancelLimitOrder, claimExpiredLimitOrder, _default as default, getClosedDcaOrders, getClosedLimitOrders, getDcaOrderExecutions, getOpenDcaOrders, getOpenLimitOrders, getSuiPrice, getTokenPrice, getTokenPrices, isAggregatorProvider, isSwapAPIProvider, placeDcaOrder, placeLimitOrder };

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _chunkKVGSSW22js = require('./chunk-KVGSSW22.js');var _client = require('@mysten/sui/client');var _transactions = require('@mysten/sui/transactions');var _utils = require('@mysten/sui/utils');var tt="0x0000000000000000000000000000000000000000000000000000000000000000";var St=["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000003","0x0000000000000000000000000000000000000000000000000000000000000004","0x0000000000000000000000000000000000000000000000000000000000000005","0x0000000000000000000000000000000000000000000000000000000000000006","0x0000000000000000000000000000000000000000000000000000000000000007","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000009","0x0000000000000000000000000000000000000000000000000000000000000403","0x000000000000000000000000000000000000000000000000000000000000000c"],v=s=>{let t=_utils.normalizeSuiAddress.call(void 0, s);return St.includes(t)};var V=class{async getObject(t){let[e,r]=await Promise.all([this.get("OwnedObject",t),this.get("SharedOrImmutableObject",t)]);return _nullishCoalesce(_nullishCoalesce(e, () => (r)), () => (null))}async getObjects(t){return Promise.all(t.map(e=>this.getObject(e)))}async addObject(t){return t.owner?await this.set("OwnedObject",t.objectId,t):await this.set("SharedOrImmutableObject",t.objectId,t),t}async addObjects(t){await Promise.all(t.map(async e=>this.addObject(e)))}async deleteObject(t){await Promise.all([this.delete("OwnedObject",t),this.delete("SharedOrImmutableObject",t)])}async deleteObjects(t){await Promise.all(t.map(e=>this.deleteObject(e)))}async getMoveFunctionDefinition(t){let e=`${_utils.normalizeSuiAddress.call(void 0, t.package)}::${t.module}::${t.function}`;return this.get("MoveFunction",e)}async addMoveFunctionDefinition(t){let e=_utils.normalizeSuiAddress.call(void 0, t.package),r=`${e}::${t.module}::${t.function}`,i={...t,package:e};return await this.set("MoveFunction",r,i),i}async deleteMoveFunctionDefinition(t){let e=`${_utils.normalizeSuiAddress.call(void 0, t.package)}::${t.module}::${t.function}`;await this.delete("MoveFunction",e)}async getCustom(t){return this.get("Custom",t)}async setCustom(t,e){return this.set("Custom",t,e)}async deleteCustom(t){return this.delete("Custom",t)}},h,q=class extends V{constructor(){super(...arguments);_chunkKVGSSW22js.b.call(void 0, this,h,{OwnedObject:new Map,SharedOrImmutableObject:new Map,MoveFunction:new Map,Custom:new Map})}async get(e,r){return _nullishCoalesce(_chunkKVGSSW22js.a.call(void 0, this,h)[e].get(r), () => (null))}async set(e,r,i){_chunkKVGSSW22js.a.call(void 0, this,h)[e].set(r,i)}async delete(e,r){_chunkKVGSSW22js.a.call(void 0, this,h)[e].delete(r)}async clear(e){if(e)_chunkKVGSSW22js.a.call(void 0, this,h)[e].clear();else for(let r of Object.values(_chunkKVGSSW22js.a.call(void 0, this,h)))r.clear()}};h=new WeakMap;var S,l,A,M=class{constructor({cache:t=new q,onEffects:e,client:r}){_chunkKVGSSW22js.b.call(void 0, this,S);_chunkKVGSSW22js.b.call(void 0, this,l);_chunkKVGSSW22js.b.call(void 0, this,A);_chunkKVGSSW22js.c.call(void 0, this,S,r),_chunkKVGSSW22js.c.call(void 0, this,l,t),_chunkKVGSSW22js.c.call(void 0, this,A,e)}async applyCache(t,e){let r=(await _chunkKVGSSW22js.a.call(void 0, this,l).getObjects(e)).filter(n=>n!==null),i=new Map(r.map(n=>[n.objectId,n])),o=[];for(let n of t.inputs){if(!n.UnresolvedObject)continue;let a=i.get(n.UnresolvedObject.objectId);if(!a){o.push(n.UnresolvedObject.objectId);continue}a.initialSharedVersion&&!n.UnresolvedObject.initialSharedVersion?n.UnresolvedObject.initialSharedVersion=a.initialSharedVersion:(a.version&&!n.UnresolvedObject.version&&(n.UnresolvedObject.version=a.version),a.digest&&!n.UnresolvedObject.digest&&(n.UnresolvedObject.digest=a.digest))}return o}async resolveObjects(t,e){let r=await this.applyCache(t,e);if(r.length===0)return[];let i=[...new Set(r)],o=await _chunkKVGSSW22js.a.call(void 0, this,S).multiGetObjects({ids:i,options:{showOwner:!0}}),n=[];for(let a of o||[]){if(!a.data)continue;let c=a.data.owner,p=c&&typeof c=="object"&&"Shared"in c?c.Shared.initial_shared_version:null,g=c&&typeof c=="object"&&"AddressOwner"in c?c.AddressOwner:null,_={objectId:a.data.objectId,version:a.data.version,digest:a.data.digest,initialSharedVersion:p,owner:g};n.push(_)}return await _chunkKVGSSW22js.a.call(void 0, this,l).addObjects(n),await this.applyCache(t,r)}asPlugin(){return async(t,e,r)=>{let i=t.inputs.filter(o=>o.UnresolvedObject).map(o=>o.UnresolvedObject.objectId);await this.resolveObjects(t,i),await Promise.all(t.commands.map(async o=>{if(o.MoveCall){let n=await this.getMoveFunctionDefinition({package:o.MoveCall.package,module:o.MoveCall.module,function:o.MoveCall.function});n&&(o.MoveCall._argumentTypes=n.parameters)}})),await r(),await Promise.all(t.commands.map(async o=>{_optionalChain([o, 'access', _2 => _2.MoveCall, 'optionalAccess', _3 => _3._argumentTypes])&&await _chunkKVGSSW22js.a.call(void 0, this,l).addMoveFunctionDefinition({package:o.MoveCall.package,module:o.MoveCall.module,function:o.MoveCall.function,parameters:o.MoveCall._argumentTypes})}))}}async clear(){await _chunkKVGSSW22js.a.call(void 0, this,l).clear()}async getMoveFunctionDefinition(t){return _chunkKVGSSW22js.a.call(void 0, this,l).getMoveFunctionDefinition(t)}async getObjects(t){return _chunkKVGSSW22js.a.call(void 0, this,l).getObjects(t)}async deleteObjects(t){return _chunkKVGSSW22js.a.call(void 0, this,l).deleteObjects(t)}async clearOwnedObjects(){await _chunkKVGSSW22js.a.call(void 0, this,l).clear("OwnedObject")}async clearCustom(){await _chunkKVGSSW22js.a.call(void 0, this,l).clear("Custom")}async getCustom(t){return _chunkKVGSSW22js.a.call(void 0, this,l).getCustom(t)}async setCustom(t,e){return _chunkKVGSSW22js.a.call(void 0, this,l).setCustom(t,e)}async deleteCustom(t){return _chunkKVGSSW22js.a.call(void 0, this,l).deleteCustom(t)}async applyEffects(t){var n;if(!t.V2)throw new Error(`Unsupported transaction effects version ${t.$kind}`);let{lamportVersion:e,changedObjects:r}=t.V2,i=[],o=[];r.forEach(([a,c])=>{if(c.outputState.NotExist)i.push(a);else if(c.outputState.ObjectWrite){let[p,g]=c.outputState.ObjectWrite;o.push({objectId:a,digest:p,version:e,owner:_nullishCoalesce(_nullishCoalesce(g.AddressOwner, () => (g.ObjectOwner)), () => (null)),initialSharedVersion:_nullishCoalesce(_optionalChain([g, 'access', _4 => _4.Shared, 'optionalAccess', _5 => _5.initialSharedVersion]), () => (null))})}}),await Promise.all([_chunkKVGSSW22js.a.call(void 0, this,l).addObjects(o),_chunkKVGSSW22js.a.call(void 0, this,l).deleteObjects(i),(n=_chunkKVGSSW22js.a.call(void 0, this,A))==null?void 0:n.call(this,t)])}};S=new WeakMap,l=new WeakMap,A=new WeakMap;var T,E=class{constructor(t){this.client=t;_chunkKVGSSW22js.b.call(void 0, this,T);this.devInspectTransactionBlock=async t=>{t.transactionBlock instanceof _transactions.Transaction&&t.transactionBlock.addBuildPlugin(_chunkKVGSSW22js.a.call(void 0, this,T).asPlugin());try{return await this.client.devInspectTransactionBlock(t)}catch(e){throw await _chunkKVGSSW22js.a.call(void 0, this,T).clear(),e}finally{await _chunkKVGSSW22js.a.call(void 0, this,T).clearOwnedObjects()}};_chunkKVGSSW22js.c.call(void 0, this,T,new M({client:this.client}))}};T=new WeakMap;var k=(s,t,e,r=0)=>{if(t>1e4)throw new Error("Slippage must be less than 100%");if(e>1e4)throw new Error("Commission must be less than 100%");if(r>1e4)throw new Error("Tip must be less than 100%");let i=BigInt(s),o=i*BigInt(r||0)/10000n,n=(i-o)*BigInt(e)/10000n,a=i-o-n,c=a*BigInt(1e4-t)/10000n;return{tipAmount:o,minAmount:c,commissionAmount:n,expectedAmount:a.toString(10)}};var X=async(s,t,e)=>{let r=await G(()=>t.devInspectTransactionBlock({sender:e.sender,transactionBlock:s}),_nullishCoalesce(e.timeout, () => (2e3)));if(r.effects.status.status==="failure")throw new (0, _chunkKVGSSW22js.l)(_nullishCoalesce(r.error, () => ("Simulation failed")),1008,{error:r.error});return{simulatedAmountOut:It(r.events),gasUsed:r.effects.gasUsed}},rt=async(s,t,e,r,i)=>{let o=new _transactions.Transaction,n=await s.swap({quote:t,coinIn:_transactions.coinWithBalance.call(void 0, {balance:BigInt(t.amountIn),type:t.coinTypeIn,useGasCoin:!1}),signer:e.sender,tx:o});o.add(P(t,n,1e4,i.tipBps,i.partner,i.partnerCommissionBps)),o.transferObjects([n],e.sender);let a=await X(o,r,e);return{id:t.id,provider:s.kind,...a}},P=(s,t,e=100,r=0,i,o=0)=>n=>{let{minAmount:a,expectedAmount:c}=k(s.rawAmountOut,e,o,r);r>0&&n.moveCall({target:`${_chunkKVGSSW22js.g}::vault::collect_tip`,typeArguments:[s.coinTypeOut],arguments:[n.object(_chunkKVGSSW22js.i),n.object(_chunkKVGSSW22js.j),t,n.pure.u64(r)]}),n.moveCall({target:`${_chunkKVGSSW22js.g}::settle::settle`,typeArguments:[s.coinTypeIn,s.coinTypeOut],arguments:[n.object(_chunkKVGSSW22js.j),n.object(_chunkKVGSSW22js.i),n.pure.u64(s.amountIn),t,n.pure.u64(a),n.pure.u64(c),n.pure.option("address",i),n.pure.u64(o),n.pure.u64(0)]})},It=s=>_optionalChain([s, 'access', _6 => _6.filter, 'call', _7 => _7(e=>e.type===`${_chunkKVGSSW22js.h}::settle::Swap`), 'optionalAccess', _8 => _8.pop, 'call', _9 => _9(), 'optionalAccess', _10 => _10.parsedJson, 'optionalAccess', _11 => _11.amount_out]),G=async(s,t,e)=>t<=0?s():new Promise((r,i)=>{let o=setTimeout(()=>i(new (0, _chunkKVGSSW22js.l)(`Timeout ${_nullishCoalesce(e, () => ("operation"))}`,1001,{timeout:t})),t);s().then(r).catch(i).finally(()=>clearTimeout(o))});var _uuid = require('uuid');var w="0x2::sui::SUI",j="0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";var Lt="https://web3.okx.com",ot="/api/v6/dex/aggregator/swap",Ut="784",st=_utils.normalizeStructTag.call(void 0, w),L=class{constructor(t,e,r){this.options=t;this.metaOptions=e;this.client=r;this.kind="okx"}async quote({amountIn:t,coinTypeIn:e,coinTypeOut:r,signer:i}){if(!i||v(i))return null;let o={chainIndex:Ut,amount:t,fromTokenAddress:e===st?w:e,toTokenAddress:r===st?w:r,slippagePercent:(this.metaOptions.slippageBps/100).toString(),userWalletAddress:i},n="?"+new URLSearchParams(o).toString(),a=`${_nullishCoalesce(this.options.api, () => (Lt))}${ot}${n}`,p=await(await fetch(a,{headers:await Bt(this.options,"GET",ot,n)})).json();return _chunkKVGSSW22js.l.assert(p.code==="0"&&p.data.length>0,"No quote found",1005,{provider:this.kind}),{id:_uuid.v4.call(void 0, ),provider:this.kind,coinTypeIn:e,coinTypeOut:r,amountIn:t,amountOut:p.data[0].routerResult.toTokenAmount,rawAmountOut:p.data[0].routerResult.toTokenAmount,quote:p.data[0]}}async fastSwap(t){let{quote:e,signer:r,signTransaction:i}=t;_chunkKVGSSW22js.l.assert(e.provider==="okx","Invalid quote",1004,{quote:e,expectedProvider:"okx"});let{tx:o,coin:n}=at({quote:e,signer:r});o.add(P(e,n,this.metaOptions.slippageBps,this.metaOptions.tipBps,this.metaOptions.partner,this.metaOptions.partnerCommissionBps)),o.transferObjects([n],r);let a=await o.build({client:this.client}),{bytes:c,signature:p}=await i(_utils.toBase64.call(void 0, a));return(await this.client.executeTransactionBlock({signature:p,transactionBlock:c})).digest}};async function Rt(s,t){let e=new TextEncoder,r=o=>{if(typeof Buffer<"u")return Buffer.from(o).toString("base64");let n="";for(let a=0;a<o.byteLength;a++)n+=String.fromCharCode(o[a]);if(typeof btoa<"u")return btoa(n);throw new (0, _chunkKVGSSW22js.l)("Base64 encoder not available in this environment")};if(typeof globalThis<"u"&&_optionalChain([globalThis, 'access', _12 => _12.crypto, 'optionalAccess', _13 => _13.subtle])){let o=await globalThis.crypto.subtle.importKey("raw",e.encode(t),{name:"HMAC",hash:"SHA-256"},!1,["sign"]),n=await globalThis.crypto.subtle.sign("HMAC",o,e.encode(s));return r(new Uint8Array(n))}let{createHmac:i}=await Promise.resolve().then(() => _interopRequireWildcard(require("crypto")));return i("sha256",t).update(s).digest("base64")}async function Bt(s,t,e,r=""){let{apiKey:i,secretKey:o,apiPassphrase:n,projectId:a}=s;if(!i||!o||!n||!a)throw new (0, _chunkKVGSSW22js.l)("Missing required environment variables");let c=new Date().toISOString(),p=c+t+e+r;return{"Content-Type":"application/json","OK-ACCESS-KEY":i,"OK-ACCESS-SIGN":await Rt(p,o),"OK-ACCESS-TIMESTAMP":c,"OK-ACCESS-PASSPHRASE":n,"OK-ACCESS-PROJECT":a}}var $t=(s,t)=>{let e=_transactions.TransactionDataBuilder.restore(s.getData()),r=e.commands.findIndex(n=>n.$kind==="MoveCall"&&_utils.normalizeSuiAddress.call(void 0, n.MoveCall.package)===_utils.normalizeSuiAddress.call(void 0, t)&&n.MoveCall.module==="router"&&n.MoveCall.function==="finalize"),i=e.commands[r];return _chunkKVGSSW22js.l.assert(i.MoveCall,"OKX: Finalize command not found",1100,{packageId:t}),e.replaceCommand(r,_transactions.Commands.MoveCall({package:t,module:"router",function:"finalize_without_transfer",typeArguments:i.MoveCall.typeArguments,arguments:[i.MoveCall.arguments[0],i.MoveCall.arguments[5],i.MoveCall.arguments[6]]})),{tx:_transactions.Transaction.from(e.build()),coin:{NestedResult:[r,0]}}},at=s=>{let{quote:t,signer:e}=s;_chunkKVGSSW22js.l.assert(t.provider==="okx","Invalid quote",1004,{quote:t,expectedProvider:"okx"});let r=_transactions.Transaction.from(t.quote.tx.data);r.setSenderIfNotSet(e);let{tx:i,coin:o}=$t(r,t.quote.tx.to);return{tx:i,coin:o}},ct=async(s,t,e,r)=>{let{tx:i,coin:o}=at({quote:s,signer:s.quote.tx.from});i.add(P(s,o,1e4,r.tipBps,r.partner,r.partnerCommissionBps)),i.transferObjects([o],s.quote.tx.from);let n=await X(i,t,e);return{id:s.id,provider:s.provider,...n}};var Vt="https://hermes.pyth.network",qt={bluefin7k:{},flowx:{},cetus:{}},U= exports.MetaAg =class{constructor(t){this.providers={};this.options={providers:{...qt,..._optionalChain([t, 'optionalAccess', _14 => _14.providers])},slippageBps:_nullishCoalesce(_optionalChain([t, 'optionalAccess', _15 => _15.slippageBps]), () => (100)),fullnodeUrl:_nullishCoalesce(_optionalChain([t, 'optionalAccess', _16 => _16.fullnodeUrl]), () => (_client.getFullnodeUrl.call(void 0, "mainnet"))),hermesApi:_nullishCoalesce(_optionalChain([t, 'optionalAccess', _17 => _17.hermesApi]), () => (Vt)),partner:_nullishCoalesce(_optionalChain([t, 'optionalAccess', _18 => _18.partner]), () => (tt)),partnerCommissionBps:_nullishCoalesce(_optionalChain([t, 'optionalAccess', _19 => _19.partnerCommissionBps]), () => (0)),tipBps:_nullishCoalesce(_optionalChain([t, 'optionalAccess', _20 => _20.tipBps]), () => (0))},this.client=new (0, _client.SuiClient)({url:this.options.fullnodeUrl}),this.inspector=new E(this.client)}async _getProvider(t){let e=this.providers[t];if(e)return e;let r=this.options.providers[t];switch(_chunkKVGSSW22js.l.assert(!!r,`Provider not found: ${t}`,1002,{provider:t}),t){case"bluefin7k":let{Bluefin7kProvider:i}=await Promise.resolve().then(() => _interopRequireWildcard(require("./bluefin7k-I6ZCDWDN.js"))).catch(W("bluefin7k"));this.providers.bluefin7k=new i(r,this.options,this.client);break;case"flowx":let{FlowxProvider:o}=await Promise.resolve().then(() => _interopRequireWildcard(require("./flowx-6M54WFWO.js"))).catch(W("flowx"));this.providers.flowx=new o(r,this.client);break;case"cetus":let{CetusProvider:n}=await Promise.resolve().then(() => _interopRequireWildcard(require("./cetus-SIPX6FYL.js"))).catch(W("cetus"));this.providers.cetus=new n(r,this.options,this.client);break;case"okx":this.providers.okx=new L(r,this.options,this.client);break;default:throw new (0, _chunkKVGSSW22js.l)(`Provider not supported: ${t}`,1003,{provider:t})}return this.providers[t]}async _simulate(t,e,r){try{if(_chunkKVGSSW22js.e.call(void 0, t))return rt(t,e,r,this.inspector,this.options);if(e.provider==="okx")return ct(e,this.inspector,r,this.options);throw new (0, _chunkKVGSSW22js.l)(`Provider not supported: ${t.kind}`,1003,{provider:t.kind})}catch(i){console.warn(i,{provider:t.kind,quote:e.id})}}async _quote(t,e){return await G(async()=>{let i=await t.quote(e);if(!i)return null;let{expectedAmount:o}=k(i.rawAmountOut,0,this.options.partnerCommissionBps,this.options.tipBps);return i.amountOut=o,i},_nullishCoalesce(e.timeout, () => (2e3)),`quote for ${t.kind} provider from ${e.coinTypeIn} to ${e.coinTypeOut}`)}async _fastSwap({quote:t,signer:e,useGasCoin:r,signTransaction:i},o){let n=new _transactions.Transaction,a=await this.swap({quote:t,signer:e,tx:n,coinIn:_transactions.coinWithBalance.call(void 0, {type:t.coinTypeIn,balance:BigInt(t.amountIn),useGasCoin:r})});n.transferObjects([a],e),n.setSenderIfNotSet(e);let c=await n.build({client:this.client}),{signature:p,bytes:g}=await i(_utils.toBase64.call(void 0, c));return this.client.executeTransactionBlock({transactionBlock:g,signature:p,options:_optionalChain([o, 'optionalAccess', _21 => _21.options]),signal:_optionalChain([o, 'optionalAccess', _22 => _22.signal])})}async quote(t,e){let r={...t,coinTypeIn:_utils.normalizeStructTag.call(void 0, t.coinTypeIn),coinTypeOut:_utils.normalizeStructTag.call(void 0, t.coinTypeOut)},o=(await Promise.allSettled(Object.entries(this.options.providers).filter(([n,a])=>!a.disabled).map(async([n])=>{let a=await this._getProvider(n);return this._quote(a,r)}))).map(n=>n.status==="fulfilled"?n.value:(console.warn(n.reason),null)).filter(n=>n!==null);if(e){let n=o.map(async a=>{let c=await this._getProvider(a.provider),p=await this._simulate(c,a,e);a.simulatedAmountOut=_optionalChain([p, 'optionalAccess', _23 => _23.simulatedAmountOut]),a.gasUsed=_optionalChain([p, 'optionalAccess', _24 => _24.gasUsed]),_optionalChain([e, 'optionalAccess', _25 => _25.onSimulated, 'optionalCall', _26 => _26({...a})])});e.onSimulated||await Promise.all(n)}return o}async swap(t,e){let r=await this._getProvider(t.quote.provider);_chunkKVGSSW22js.l.assert(!!r,`Provider not found: ${t.quote.provider}`,1002,{provider:t.quote.provider}),_chunkKVGSSW22js.l.assert(_chunkKVGSSW22js.e.call(void 0, r),`Provider does not support swap: ${r.kind}, use fastSwap instead`,1007,{provider:r.kind}),_chunkKVGSSW22js.l.assert(t.signer&&!v(t.signer),"Invalid signer address",1006,{signer:t.signer});let i=await r.swap(t);return t.tx.add(P(t.quote,i,_nullishCoalesce(_nullishCoalesce(e, () => (this.options.slippageBps)), () => (100)),this.options.tipBps,this.options.partner,this.options.partnerCommissionBps)),t.tx.setSenderIfNotSet(t.signer),i}async fastSwap(t,e){_chunkKVGSSW22js.l.assert(t.signer&&!v(t.signer),"Invalid signer address",1006,{signer:t.signer});let r=await this._getProvider(t.quote.provider);if(_chunkKVGSSW22js.e.call(void 0, r))return this._fastSwap(t,e);if(_chunkKVGSSW22js.f.call(void 0, r))return this.client.waitForTransaction({...e,digest:await r.fastSwap(t)});throw new (0, _chunkKVGSSW22js.l)(`Provider not supported: ${r.kind}`,1003,{provider:r.kind})}updateMetaAgOptions(t){if(Object.keys(t).length!==0){this.options.slippageBps=_nullishCoalesce(t.slippageBps, () => (this.options.slippageBps)),this.options.partner=_nullishCoalesce(t.partner, () => (this.options.partner)),this.options.partnerCommissionBps=_nullishCoalesce(t.partnerCommissionBps, () => (this.options.partnerCommissionBps)),this.options.tipBps=_nullishCoalesce(t.tipBps, () => (this.options.tipBps)),t.fullnodeUrl&&t.fullnodeUrl!==this.options.fullnodeUrl&&(this.client=new (0, _client.SuiClient)({url:t.fullnodeUrl}),this.inspector=new E(this.client),this.options.fullnodeUrl=t.fullnodeUrl),t.hermesApi&&t.hermesApi!==this.options.hermesApi&&(this.providers={},this.options.hermesApi=t.hermesApi);for(let[e,r]of Object.entries(t.providers||{}))this.options.providers[e]={...r,...this.options.providers[e]},delete this.providers[e]}}},W=s=>t=>{let e={cetus:"@cetusprotocol/aggregator-sdk",flowx:"@flowx-finance/sdk",bluefin7k:"@bluefin-exchange/bluefin7k-aggregator-sdk",okx:""};throw console.warn(`Please install ${e[s]} to use ${s} provider`),t};async function d(s,t){let e=new Headers(_optionalChain([t, 'optionalAccess', _27 => _27.headers])),r={...t,headers:e};return fetch(s,r)}var R={MAIN:"https://api.7k.ag",LO_DCA:"https://lod-dca.7k.ag",PRICES:"https://lp-pro-api.7k.ag/price",STATISTIC:"https://statistic.7k.ag"};function B(s){return s===w?j:s}var Xt=(s,t)=>{let e=[];for(let r=0;r<s.length;r+=t)e.push(s.slice(r,r+t));return e},mt=500,Gt=100;function Wt(){return Math.floor(Date.now()/1e3).toString()}async function z(s){try{let t=B(s);return(await H([t]))[t]||0}catch (e2){return 0}}async function H(s){try{if(s.length===0)return{};let t=s.slice(0,mt).map(B),e=Xt(t,Gt),r=Wt(),o=(await Promise.all(e.map(async a=>{let c={timestamp:r,token_ids:a},p=await d(`${R.PRICES}/prices/batch`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(c)});if(!p.ok)throw new Error(`Price API returned status ${p.status}`);return await p.json()}))).reduce((a,c)=>(c.forEach(p=>{a[p.token_id]=p.price}),a),{});return t.reduce((a,c)=>(a[c]=o[c]||0,a),{})}catch (e3){return s.slice(0,mt).reduce((e,r)=>(e[B(r)]=0,e),{})}}async function lt(){return await z(j)}var $="0xffc7f420b481ed7a012b42e125fd7e5716b5673759cf4629e5fcfebce970a72d",br=BigInt("1000000000000"),vr=BigInt("10000"),Y="0x0ef0f805710cf53c10f29c4f73e1144a662747e1839689a846e2520cae122adc",b=`${Y}::limit_order`,F=`${Y}::dca_order`,Sr=`${Y}::config`,Ar=BigInt("18446744073709551615"),f=`${R.LO_DCA}/api`;async function dt({accountAddress:s,payCoinType:t,targetCoinType:e,payCoinAmount:r,rate:i,slippage:o,expireTs:n,devInspect:a}){let c=new _transactions.Transaction,p=c.add(_transactions.coinWithBalance.call(void 0, {type:t,balance:r,useGasCoin:!a}));return c.moveCall({target:`${b}::place_limit_order`,arguments:[c.object($),p,c.pure.u64(i),c.pure.u64(o),c.pure.u64(n),c.object.clock()],typeArguments:[t,e]}),c.setSenderIfNotSet(s),c}async function gt({orderId:s,payCoinType:t,targetCoinType:e}){let r=new _transactions.Transaction;return r.moveCall({target:`${b}::cancel_limit_order`,typeArguments:[t,e],arguments:[r.object(s),r.object.clock()]}),r}async function ft({orderId:s,payCoinType:t,targetCoinType:e}){let r=new _transactions.Transaction;return r.moveCall({target:`${b}::claim_expired_order`,typeArguments:[t,e],arguments:[r.object(s),r.object.clock()]}),r}function O(s){let t="";return Object.entries(s).forEach(([e,r])=>{if(Array.isArray(r))for(let i of r)t+=t?`&${e}=${i}`:`${e}=${i}`;else r!==void 0&&(t+=t?`&${e}=${r}`:`${e}=${r}`)}),t}async function Ot({owner:s,offset:t=0,limit:e=10,tokenPair:r}){let o=O({owner:s,statuses:["ACTIVE","EXPIRED"],offset:t,limit:e,tokenPair:r}),n=await d(`${f}/limit-orders?${o}`);if(!n.ok)throw new Error("Failed to fetch open limit orders");return await n.json()}async function ht({owner:s,offset:t=0,limit:e=10,tokenPair:r}){let o=O({owner:s,statuses:["CLOSED"],offset:t,limit:e,tokenPair:r}),n=await d(`${f}/limit-orders?${o}`);if(!n.ok)throw new Error("Failed to fetch closed limit orders");return await n.json()}async function yt({payCoinType:s,targetCoinType:t,payCoinAmountEach:e,numOrders:r,interval:i,slippage:o,minRate:n,maxRate:a}){let c=new _transactions.Transaction,p=[];for(let _=0;_<r;_++){let bt=_transactions.coinWithBalance.call(void 0, {type:s,balance:e});p.push(bt)}let g=c.makeMoveVec({elements:p});return c.moveCall({target:`${F}::place_dca_order`,arguments:[c.object($),g,c.pure.u64(i),c.pure.u64(o),c.pure.u64(n),c.pure.u64(a),c.object.clock()],typeArguments:[s,t]}),c}async function Tt({orderId:s,payCoinType:t,targetCoinType:e}){let r=new _transactions.Transaction;return r.moveCall({target:`${F}::cancel_dca_order`,arguments:[r.object(s),r.object.clock()],typeArguments:[t,e]}),r}async function Ct({owner:s,offset:t=0,limit:e=10,tokenPair:r}){let o=O({owner:s,statuses:["ACTIVE","EXPIRED"],offset:t,limit:e,tokenPair:r}),n=await d(`${f}/dca-orders?${o}`);if(!n.ok)throw new Error("Failed to fetch open dca orders");return await n.json()}async function Pt({owner:s,offset:t=0,limit:e=10,tokenPair:r}){let o=O({owner:s,statuses:["SUCCESS"],offset:t,limit:e,orderType:"DCA",tokenPair:r}),n=await d(`${f}/order-executions?${o}`);if(!n.ok)throw new Error("Failed to fetch closed dca orders");return await n.json()}async function wt({owner:s,orderId:t,offset:e=0,limit:r=10}){let o=O({owner:s,orderId:t,statuses:["SUCCESS"],offset:e,limit:r,orderType:"DCA"}),n=await d(`${f}/order-executions?${o}`);if(!n.ok)throw new Error("Failed to fetch dca order executions");return await n.json()}var An={getTokenPrice:z,getTokenPrices:H,getSuiPrice:lt,placeLimitOrder:dt,getOpenLimitOrders:Ot,cancelLimitOrder:gt,claimExpiredLimitOrder:ft,getClosedLimitOrders:ht,placeDcaOrder:yt,getOpenDcaOrders:Ct,cancelDcaOrder:Tt,getClosedDcaOrders:Pt,getDcaOrderExecutions:wt,MetaAg:U};exports.EProvider = _chunkKVGSSW22js.d; exports.MetaAg = U; exports.cancelDcaOrder = Tt; exports.cancelLimitOrder = gt; exports.claimExpiredLimitOrder = ft; exports.default = An; exports.getClosedDcaOrders = Pt; exports.getClosedLimitOrders = ht; exports.getDcaOrderExecutions = wt; exports.getOpenDcaOrders = Ct; exports.getOpenLimitOrders = Ot; exports.getSuiPrice = lt; exports.getTokenPrice = z; exports.getTokenPrices = H; exports.isAggregatorProvider = _chunkKVGSSW22js.e; exports.isSwapAPIProvider = _chunkKVGSSW22js.f; exports.placeDcaOrder = yt; exports.placeLimitOrder = dt;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/otis/Documents/7k-ts-sdk/dist/index.js","../src/features/metaAg/index.ts","../src/constants/sui.ts","../src/utils/sui.ts","../src/utils/SuiClientUtils.ts","../src/utils/ObjectCache.ts"],"names":["SUI_ADDRESS_ZERO","RESERVED_ADDRESSES","isSystemAddress","address","addr","normalizeSuiAddress","AsyncCache","id","owned","shared","ids","object","objects","ref","functionName"],"mappings":"AAAA,y/BAA6G,4CCKtG,wDAKA,0CACsC,ICXhCA,EAAAA,CACX,oEAAA,CCAF,IAiHMC,EAAAA,CAAqB,CACzB,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEAAA,CACA,oEACF,CAAA,CAEaC,CAAAA,CAAmBC,CAAAA,EAAoB,CAClD,IAAMC,CAAAA,CAAOC,wCAAAA,CAA2B,CAAA,CACxC,OAAOJ,EAAAA,CAAmB,QAAA,CAASG,CAAI,CACzC,CAAA,CChIA,IC0BsBE,CAAAA,CAAf,KAA0B,CAgB/B,MAAM,SAAA,CAAUC,CAAAA,CAAY,CAC1B,GAAM,CAACC,CAAAA,CAAOC,CAAM,CAAA,CAAI,MAAM,OAAA,CAAQ,GAAA,CAAI,CACxC,IAAA,CAAK,GAAA,CAAI,aAAA,CAAeF,CAAE,CAAA,CAC1B,IAAA,CAAK,GAAA,CAAI,yBAAA,CAA2BA,CAAE,CACxC,CAAC,CAAA,CAED,yCAAOC,CAAAA,SAASC,GAAAA,SAAU,MAC5B,CAEA,MAAM,UAAA,CAAWC,CAAAA,CAAe,CAC9B,OAAO,OAAA,CAAQ,GAAA,CAAIA,CAAAA,CAAI,GAAA,CAAKH,CAAAA,EAAO,IAAA,CAAK,SAAA,CAAUA,CAAE,CAAC,CAAC,CACxD,CAEA,MAAM,SAAA,CAAUI,CAAAA,CAA0B,CACxC,OAAIA,CAAAA,CAAO,KAAA,CACT,MAAM,IAAA,CAAK,GAAA,CAAI,aAAA,CAAeA,CAAAA,CAAO,QAAA,CAAUA,CAAM,CAAA,CAErD,MAAM,IAAA,CAAK,GAAA,CAAI,yBAAA,CAA2BA,CAAAA,CAAO,QAAA,CAAUA,CAAM,CAAA,CAG5DA,CACT,CAEA,MAAM,UAAA,CAAWC,CAAAA,CAA6B,CAC5C,MAAM,OAAA,CAAQ,GAAA,CAAIA,CAAAA,CAAQ,GAAA,CAAI,MAAOD,CAAAA,EAAW,IAAA,CAAK,SAAA,CAAUA,CAAM,CAAC,CAAC,CACzE,CAEA,MAAM,YAAA,CAAaJ,CAAAA,CAAY,CAC7B,MAAM,OAAA,CAAQ,GAAA,CAAI,CAChB,IAAA,CAAK,MAAA,CAAO,aAAA,CAAeA,CAAE,CAAA,CAC7B,IAAA,CAAK,MAAA,CAAO,yBAAA,CAA2BA,CAAE,CAC3C,CAAC,CACH,CAEA,MAAM,aAAA,CAAcG,CAAAA,CAAe,CACjC,MAAM,OAAA,CAAQ,GAAA,CAAIA,CAAAA,CAAI,GAAA,CAAKH,CAAAA,EAAO,IAAA,CAAK,YAAA,CAAaA,CAAE,CAAC,CAAC,CAC1D,CAEA,MAAM,yBAAA,CAA0BM,CAAAA,CAI7B,CACD,IAAMC,CAAAA,CAAe,CAAA,EAAA","file":"/Users/otis/Documents/7k-ts-sdk/dist/index.js","sourcesContent":[null,"import {\n  getFullnodeUrl,\n  GetTransactionBlockParams,\n  SuiClient,\n  SuiTransactionBlockResponse,\n} from \"@mysten/sui/client\";\nimport {\n  coinWithBalance,\n  Transaction,\n  TransactionObjectArgument,\n} from \"@mysten/sui/transactions\";\nimport { normalizeStructTag, toBase64 } from \"@mysten/sui/utils\";\nimport { SUI_ADDRESS_ZERO } from \"../../constants/sui\";\nimport {\n  Bluefin7kProviderOptions,\n  CetusProviderOptions,\n  EProvider,\n  FlowxProviderOptions,\n  isAggregatorProvider,\n  isSwapAPIProvider,\n  MetaAgOptions,\n  MetaFastSwapOptions,\n  MetaQuote,\n  MetaQuoteOptions,\n  MetaSimulationOptions,\n  MetaSwapOptions,\n  OkxProviderOptions,\n  QuoteProvider,\n} from \"../../types/metaAg\";\nimport { isSystemAddress } from \"../../utils/sui\";\nimport { SuiClientUtils } from \"../../utils/SuiClientUtils\";\nimport { getExpectedReturn } from \"../../utils/swap\";\nimport { metaSettle, simulateAggregator, timeout } from \"./common\";\nimport { MetaAgError, MetaAgErrorCode } from \"./error\";\nimport { OkxProvider, simulateOKXSwap } from \"./providers/okx\";\n\nconst HERMES_API = \"https://hermes.pyth.network\";\n\nconst DEFAULT_PROVIDERS: Required<MetaAgOptions>[\"providers\"] = {\n  [EProvider.BLUEFIN7K]: {},\n  [EProvider.FLOWX]: {},\n  [EProvider.CETUS]: {},\n};\n\nexport class MetaAg {\n  client: SuiClient;\n  private providers: Partial<Record<EProvider, QuoteProvider>> = {};\n  private inspector: SuiClientUtils;\n  private options: Required<MetaAgOptions>;\n  constructor(options?: MetaAgOptions) {\n    this.options = {\n      providers: { ...DEFAULT_PROVIDERS, ...options?.providers },\n      slippageBps: options?.slippageBps ?? 100,\n      fullnodeUrl: options?.fullnodeUrl ?? getFullnodeUrl(\"mainnet\"),\n      hermesApi: options?.hermesApi ?? HERMES_API,\n      partner: options?.partner ?? SUI_ADDRESS_ZERO,\n      partnerCommissionBps: options?.partnerCommissionBps ?? 0,\n      tipBps: options?.tipBps ?? 0,\n    };\n\n    this.client = new SuiClient({\n      url: this.options.fullnodeUrl,\n    });\n\n    this.inspector = new SuiClientUtils(this.client);\n  }\n\n  private async _getProvider(provider: EProvider) {\n    const p = this.providers[provider];\n    if (p) return p;\n\n    const providerOptions = this.options.providers[provider];\n    MetaAgError.assert(\n      !!providerOptions,\n      `Provider not found: ${provider}`,\n      MetaAgErrorCode.PROVIDER_NOT_FOUND,\n      { provider }\n    );\n    switch (provider) {\n      case EProvider.BLUEFIN7K:\n        const { Bluefin7kProvider } = await import(\n          \"./providers/bluefin7k\"\n        ).catch(catchImportError(EProvider.BLUEFIN7K));\n        this.providers[EProvider.BLUEFIN7K] = new Bluefin7kProvider(\n          providerOptions as Bluefin7kProviderOptions,\n          this.options,\n          this.client\n        );\n        break;\n      case EProvider.FLOWX:\n        const { FlowxProvider } = await import(\"./providers/flowx\").catch(\n          catchImportError(EProvider.FLOWX)\n        );\n        this.providers[EProvider.FLOWX] = new FlowxProvider(\n          providerOptions as FlowxProviderOptions,\n          this.client\n        );\n        break;\n      case EProvider.CETUS:\n        const { CetusProvider } = await import(\"./providers/cetus\").catch(\n          catchImportError(EProvider.CETUS)\n        );\n        this.providers[EProvider.CETUS] = new CetusProvider(\n          providerOptions as CetusProviderOptions,\n          this.options,\n          this.client\n        );\n        break;\n      case EProvider.OKX:\n        this.providers[EProvider.OKX] = new OkxProvider(\n          providerOptions as OkxProviderOptions,\n          this.options,\n          this.client\n        );\n        break;\n      default:\n        throw new MetaAgError(\n          `Provider not supported: ${provider}`,\n          MetaAgErrorCode.PROVIDER_NOT_SUPPORTED,\n          { provider }\n        );\n    }\n    return this.providers[provider]!;\n  }\n\n  private async _simulate(\n    provider: QuoteProvider,\n    quote: MetaQuote,\n    simulation: MetaSimulationOptions\n  ) {\n    try {\n      if (isAggregatorProvider(provider)) {\n        return simulateAggregator(\n          provider,\n          quote,\n          simulation,\n          this.inspector,\n          this.options\n        );\n      }\n\n      switch (quote.provider) {\n        case EProvider.OKX:\n          return simulateOKXSwap(\n            quote,\n            this.inspector,\n            simulation,\n            this.options\n          );\n        default:\n          throw new MetaAgError(\n            `Provider not supported: ${provider.kind}`,\n            MetaAgErrorCode.PROVIDER_NOT_SUPPORTED,\n            { provider: provider.kind }\n          );\n      }\n    } catch (error) {\n      console.warn(error, { provider: provider.kind, quote: quote.id });\n    }\n  }\n\n  private async _quote(provider: QuoteProvider, options: MetaQuoteOptions) {\n    const quote = await timeout(\n      async () => {\n        const quote = await provider.quote(options);\n        if (!quote) return null;\n        const { expectedAmount } = getExpectedReturn(\n          quote.rawAmountOut,\n          0,\n          this.options.partnerCommissionBps,\n          this.options.tipBps\n        );\n        quote.amountOut = expectedAmount;\n        return quote;\n      },\n      options.timeout ?? 2000,\n      `quote for ${provider.kind} provider from ${options.coinTypeIn} to ${options.coinTypeOut}`\n    );\n\n    return quote;\n  }\n\n  private async _fastSwap(\n    { quote, signer, useGasCoin, signTransaction }: MetaFastSwapOptions,\n    getTransactionBlockParams?: Omit<GetTransactionBlockParams, \"digest\">\n  ) {\n    const tx = new Transaction();\n    const coin = await this.swap({\n      quote,\n      signer,\n      tx,\n      coinIn: coinWithBalance({\n        type: quote.coinTypeIn,\n        balance: BigInt(quote.amountIn),\n        useGasCoin,\n      }),\n    });\n    tx.transferObjects([coin], signer);\n    tx.setSenderIfNotSet(signer);\n    const txBytes = await tx.build({ client: this.client });\n    const { signature, bytes } = await signTransaction(toBase64(txBytes));\n    return this.client.executeTransactionBlock({\n      transactionBlock: bytes,\n      signature,\n      options: getTransactionBlockParams?.options,\n      signal: getTransactionBlockParams?.signal,\n    });\n  }\n\n  /**\n   * Get quotes from all providers\n   * @param options - quote options\n   * @param simulation - if present, the quote will be simulated\n   * @returns quotes from all providers\n   */\n  async quote(\n    options: MetaQuoteOptions,\n    simulation?: MetaSimulationOptions\n  ): Promise<MetaQuote[]> {\n    const opts: MetaQuoteOptions = {\n      ...options,\n      coinTypeIn: normalizeStructTag(options.coinTypeIn),\n      coinTypeOut: normalizeStructTag(options.coinTypeOut),\n    };\n    const quotes = await Promise.allSettled(\n      Object.entries(this.options.providers)\n        .filter(([_k, v]) => !v.disabled)\n        .map(async ([provider]) => {\n          const p = await this._getProvider(provider as EProvider);\n          return this._quote(p, opts);\n        })\n    );\n    const result = quotes\n      .map((quote) =>\n        quote.status === \"fulfilled\"\n          ? quote.value\n          : (console.warn(quote.reason), null)\n      )\n      .filter((quote) => quote !== null);\n\n    if (simulation) {\n      const requests = result.map(async (quote) => {\n        const provider = await this._getProvider(quote.provider);\n        const updated = await this._simulate(provider, quote, simulation);\n        quote.simulatedAmountOut = updated?.simulatedAmountOut;\n        quote.gasUsed = updated?.gasUsed;\n        simulation?.onSimulated?.({ ...quote });\n      });\n      if (!simulation.onSimulated) {\n        await Promise.all(requests);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Build transaction from quote\n   * @info Use this function to build composable transaction (ie: add more commands after the swap, consume the coin out object)\n   * @warning Providers that build transaction on the fly (typically RFQ, Swap-API providers ie: Okx, ...) are not supported, please use `fastSwap` instead\n   * @param options - build tx options\n   * @param slippageBps - slippage bps if not specified, fallback to global slippage bps, if none of them specified, default to 100\n   * @returns coin out object, you must consume it by transferObjects, or other sub sequence commands\n   */\n  async swap(\n    options: MetaSwapOptions,\n    slippageBps?: number\n  ): Promise<TransactionObjectArgument> {\n    const provider = await this._getProvider(options.quote.provider);\n    MetaAgError.assert(\n      !!provider,\n      `Provider not found: ${options.quote.provider}`,\n      MetaAgErrorCode.PROVIDER_NOT_FOUND,\n      { provider: options.quote.provider }\n    );\n    MetaAgError.assert(\n      isAggregatorProvider(provider),\n      `Provider does not support swap: ${provider.kind}, use fastSwap instead`,\n      MetaAgErrorCode.PROVIDER_NOT_SUPPORT_SWAP,\n      { provider: provider.kind }\n    );\n    MetaAgError.assert(\n      options.signer && !isSystemAddress(options.signer),\n      \"Invalid signer address\",\n      MetaAgErrorCode.INVALID_SIGNER_ADDRESS,\n      { signer: options.signer }\n    );\n    const coinOut = await provider.swap(options);\n    options.tx.add(\n      metaSettle(\n        options.quote,\n        coinOut,\n        slippageBps ?? this.options.slippageBps ?? 100,\n        this.options.tipBps,\n        this.options.partner,\n        this.options.partnerCommissionBps\n      )\n    );\n    options.tx.setSenderIfNotSet(options.signer);\n    return coinOut;\n  }\n\n  /**\n   * Build, Sign, and Execute transaction in one step\n   * @param options - fast swap options\n   * @returns - txDigest of the transaction\n   */\n  async fastSwap(\n    options: MetaFastSwapOptions,\n    getTransactionBlockParams?: Omit<GetTransactionBlockParams, \"digest\">\n  ): Promise<SuiTransactionBlockResponse> {\n    MetaAgError.assert(\n      options.signer && !isSystemAddress(options.signer),\n      \"Invalid signer address\",\n      MetaAgErrorCode.INVALID_SIGNER_ADDRESS,\n      { signer: options.signer }\n    );\n    const provider = await this._getProvider(options.quote.provider);\n    if (isAggregatorProvider(provider)) {\n      return this._fastSwap(options, getTransactionBlockParams);\n    } else if (isSwapAPIProvider(provider)) {\n      return this.client.waitForTransaction({\n        ...getTransactionBlockParams,\n        digest: await provider.fastSwap(options),\n      });\n    } else {\n      throw new MetaAgError(\n        `Provider not supported: ${provider.kind}`,\n        MetaAgErrorCode.PROVIDER_NOT_SUPPORTED,\n        { provider: provider.kind }\n      );\n    }\n  }\n\n  /**\n   * Update meta aggregator options\n   * @param options - update options payload\n   */\n  updateMetaAgOptions(options: MetaAgOptions) {\n    if (Object.keys(options).length === 0) return;\n    this.options.slippageBps = options.slippageBps ?? this.options.slippageBps;\n    this.options.partner = options.partner ?? this.options.partner;\n    this.options.partnerCommissionBps =\n      options.partnerCommissionBps ?? this.options.partnerCommissionBps;\n    this.options.tipBps = options.tipBps ?? this.options.tipBps;\n    if (\n      options.fullnodeUrl &&\n      options.fullnodeUrl !== this.options.fullnodeUrl\n    ) {\n      this.client = new SuiClient({ url: options.fullnodeUrl });\n      this.inspector = new SuiClientUtils(this.client);\n      this.options.fullnodeUrl = options.fullnodeUrl;\n    }\n    if (options.hermesApi && options.hermesApi !== this.options.hermesApi) {\n      this.providers = {};\n      this.options.hermesApi = options.hermesApi;\n    }\n    // if update provider's options, we need to re-initialize the provider\n    for (const [provider, opt] of Object.entries(options.providers || {})) {\n      this.options.providers[provider as EProvider] = {\n        ...opt,\n        ...this.options.providers[provider as EProvider],\n      } as any;\n      delete this.providers[provider as EProvider];\n    }\n  }\n}\n\nconst catchImportError = (provider: EProvider) => {\n  return (e: any) => {\n    const map = {\n      [EProvider.CETUS]: \"@cetusprotocol/aggregator-sdk\",\n      [EProvider.FLOWX]: \"@flowx-finance/sdk\",\n      [EProvider.BLUEFIN7K]: \"@bluefin-exchange/bluefin7k-aggregator-sdk\",\n      [EProvider.OKX]: \"\",\n    };\n    console.warn(`Please install ${map[provider]} to use ${provider} provider`);\n    throw e;\n  };\n};\n","export const SUI_ADDRESS_ZERO =\n  \"0x0000000000000000000000000000000000000000000000000000000000000000\";\n","import { Transaction, TransactionArgument } from \"@mysten/sui/transactions\";\nimport { normalizeSuiAddress, parseStructTag } from \"@mysten/sui/utils\";\nimport {\n  _7K_META_CONFIG,\n  _7K_META_PACKAGE_ID,\n  _7K_META_VAULT,\n} from \"../constants/_7k\";\n\nexport const SuiUtils = {\n  getSuiCoin(\n    amount: bigint | TransactionArgument,\n    txb: Transaction,\n  ): TransactionArgument {\n    const [coin] = txb.splitCoins(txb.gas, [amount]);\n    return coin;\n  },\n\n  getCoinValue(\n    coinType: string,\n    coinObject: string | TransactionArgument,\n    txb: Transaction,\n  ): TransactionArgument {\n    const inputCoinObject =\n      typeof coinObject == \"string\" ? txb.object(coinObject) : coinObject;\n    const [value] = txb.moveCall({\n      target: `0x2::coin::value`,\n      typeArguments: [coinType],\n      arguments: [inputCoinObject],\n    });\n    return value;\n  },\n\n  isValidStructTag(value: string) {\n    try {\n      return !!parseStructTag(value);\n    } catch (_) {\n      return false;\n    }\n  },\n\n  zeroBalance(tx: Transaction, coinType: string) {\n    return tx.moveCall({\n      target: `0x2::balance::zero`,\n      typeArguments: [coinType],\n      arguments: [],\n    })[0];\n  },\n\n  zeroCoin(tx: Transaction, coinType: string) {\n    return tx.moveCall({\n      target: `0x2::coin::zero`,\n      typeArguments: [coinType],\n      arguments: [],\n    })[0];\n  },\n\n  coinIntoBalance(\n    tx: Transaction,\n    coinType: string,\n    coinObject: TransactionArgument,\n  ) {\n    return tx.moveCall({\n      target: `0x2::coin::into_balance`,\n      typeArguments: [coinType],\n      arguments: [coinObject],\n    })[0];\n  },\n\n  coinFromBalance(\n    tx: Transaction,\n    coinType: string,\n    balance: TransactionArgument,\n  ) {\n    return tx.moveCall({\n      target: `0x2::coin::from_balance`,\n      typeArguments: [coinType],\n      arguments: [balance],\n    })[0];\n  },\n\n  balanceDestroyZero(\n    tx: Transaction,\n    coinType: string,\n    balance: TransactionArgument,\n  ) {\n    tx.moveCall({\n      target: `0x2::balance::destroy_zero`,\n      typeArguments: [coinType],\n      arguments: [balance],\n    });\n  },\n\n  collectDust(tx: Transaction, coinType: string, coin: TransactionArgument) {\n    tx.moveCall({\n      target: `${_7K_META_PACKAGE_ID}::vault::collect_dust`,\n      typeArguments: [coinType],\n      arguments: [tx.object(_7K_META_VAULT), tx.object(_7K_META_CONFIG), coin],\n    });\n  },\n\n  transferOrDestroyZeroCoin(\n    tx: Transaction,\n    coinType: string,\n    coin: TransactionArgument,\n    address: string,\n  ) {\n    tx.moveCall({\n      target: `${_7K_META_PACKAGE_ID}::utils::transfer_or_destroy`,\n      typeArguments: [coinType],\n      arguments: [coin, tx.pure.address(address)],\n    });\n  },\n};\n\nconst RESERVED_ADDRESSES = [\n  \"0x0000000000000000000000000000000000000000000000000000000000000000\", // zero\n  \"0x0000000000000000000000000000000000000000000000000000000000000001\", // std\n  \"0x0000000000000000000000000000000000000000000000000000000000000002\", // sui framework\n  \"0x0000000000000000000000000000000000000000000000000000000000000003\", // unknown but we reserved to be safe\n  \"0x0000000000000000000000000000000000000000000000000000000000000004\", // unknown but we reserved to be safe\n  \"0x0000000000000000000000000000000000000000000000000000000000000005\", // system state\n  \"0x0000000000000000000000000000000000000000000000000000000000000006\", // time\n  \"0x0000000000000000000000000000000000000000000000000000000000000007\", // unknown but we reserved to be safe\n  \"0x0000000000000000000000000000000000000000000000000000000000000008\", // random\n  \"0x0000000000000000000000000000000000000000000000000000000000000009\", // unknown but we reserved to be safe\n  \"0x0000000000000000000000000000000000000000000000000000000000000403\", // coin deny list\n  \"0x000000000000000000000000000000000000000000000000000000000000000c\", // coin registry\n];\n\nexport const isSystemAddress = (address: string) => {\n  const addr = normalizeSuiAddress(address);\n  return RESERVED_ADDRESSES.includes(addr);\n};\n","import {\n  DevInspectTransactionBlockParams,\n  SuiClient,\n} from \"@mysten/sui/client\";\nimport { Transaction } from \"@mysten/sui/transactions\";\nimport { CustomObjectCache } from \"./ObjectCache\";\n\n/**\n * Utility class for interacting with Sui blockchain coins\n */\nexport class SuiClientUtils {\n  #devInspectCache: CustomObjectCache;\n  /**\n   * Creates a new instance of SuiClientUtils\n   * @param client - The Sui client instance to use for blockchain interactions\n   */\n  constructor(private client: SuiClient) {\n    this.#devInspectCache = new CustomObjectCache({ client: this.client });\n  }\n\n  devInspectTransactionBlock = async (\n    params: DevInspectTransactionBlockParams,\n  ) => {\n    if (params.transactionBlock instanceof Transaction) {\n      params.transactionBlock.addBuildPlugin(this.#devInspectCache.asPlugin());\n    }\n    try {\n      const res = await this.client.devInspectTransactionBlock(params);\n      return res;\n    } catch (error) {\n      // clear all cache if devInspectTransactionBlock fails\n      await this.#devInspectCache.clear();\n      throw error;\n    } finally {\n      await this.#devInspectCache.clearOwnedObjects();\n    }\n  };\n}\n","import { bcs } from \"@mysten/sui/bcs\";\nimport { SuiClient } from \"@mysten/sui/client\";\nimport {\n  OpenMoveTypeSignature,\n  TransactionDataBuilder,\n  TransactionPlugin,\n} from \"@mysten/sui/transactions\";\nimport { normalizeSuiAddress } from \"@mysten/sui/utils\";\n\nexport interface ObjectCacheEntry {\n  objectId: string;\n  version: string;\n  digest: string;\n  owner: string | null;\n  initialSharedVersion: string | null;\n}\n\nexport interface MoveFunctionCacheEntry {\n  package: string;\n  module: string;\n  function: string;\n  parameters: OpenMoveTypeSignature[];\n}\n\nexport interface CacheEntryTypes {\n  OwnedObject: ObjectCacheEntry;\n  SharedOrImmutableObject: ObjectCacheEntry;\n  MoveFunction: MoveFunctionCacheEntry;\n  Custom: unknown;\n}\nexport abstract class AsyncCache {\n  protected abstract get<T extends keyof CacheEntryTypes>(\n    type: T,\n    key: string,\n  ): Promise<CacheEntryTypes[T] | null>;\n  protected abstract set<T extends keyof CacheEntryTypes>(\n    type: T,\n    key: string,\n    value: CacheEntryTypes[T],\n  ): Promise<void>;\n  protected abstract delete<T extends keyof CacheEntryTypes>(\n    type: T,\n    key: string,\n  ): Promise<void>;\n  abstract clear<T extends keyof CacheEntryTypes>(type?: T): Promise<void>;\n\n  async getObject(id: string) {\n    const [owned, shared] = await Promise.all([\n      this.get(\"OwnedObject\", id),\n      this.get(\"SharedOrImmutableObject\", id),\n    ]);\n\n    return owned ?? shared ?? null;\n  }\n\n  async getObjects(ids: string[]) {\n    return Promise.all(ids.map((id) => this.getObject(id)));\n  }\n\n  async addObject(object: ObjectCacheEntry) {\n    if (object.owner) {\n      await this.set(\"OwnedObject\", object.objectId, object);\n    } else {\n      await this.set(\"SharedOrImmutableObject\", object.objectId, object);\n    }\n\n    return object;\n  }\n\n  async addObjects(objects: ObjectCacheEntry[]) {\n    await Promise.all(objects.map(async (object) => this.addObject(object)));\n  }\n\n  async deleteObject(id: string) {\n    await Promise.all([\n      this.delete(\"OwnedObject\", id),\n      this.delete(\"SharedOrImmutableObject\", id),\n    ]);\n  }\n\n  async deleteObjects(ids: string[]) {\n    await Promise.all(ids.map((id) => this.deleteObject(id)));\n  }\n\n  async getMoveFunctionDefinition(ref: {\n    package: string;\n    module: string;\n    function: string;\n  }) {\n    const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`;\n    return this.get(\"MoveFunction\", functionName);\n  }\n\n  async addMoveFunctionDefinition(functionEntry: MoveFunctionCacheEntry) {\n    const pkg = normalizeSuiAddress(functionEntry.package);\n    const functionName = `${pkg}::${functionEntry.module}::${functionEntry.function}`;\n    const entry = {\n      ...functionEntry,\n      package: pkg,\n    };\n\n    await this.set(\"MoveFunction\", functionName, entry);\n\n    return entry;\n  }\n\n  async deleteMoveFunctionDefinition(ref: {\n    package: string;\n    module: string;\n    function: string;\n  }) {\n    const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`;\n    await this.delete(\"MoveFunction\", functionName);\n  }\n\n  async getCustom<T>(key: string) {\n    return this.get(\"Custom\", key) as Promise<T | null>;\n  }\n\n  async setCustom<T>(key: string, value: T) {\n    return this.set(\"Custom\", key, value);\n  }\n\n  async deleteCustom(key: string) {\n    return this.delete(\"Custom\", key);\n  }\n}\n\nexport class InMemoryObjectCache extends AsyncCache {\n  #caches = {\n    OwnedObject: new Map<string, ObjectCacheEntry>(),\n    SharedOrImmutableObject: new Map<string, ObjectCacheEntry>(),\n    MoveFunction: new Map<string, MoveFunctionCacheEntry>(),\n    Custom: new Map<string, unknown>(),\n  };\n\n  protected async get<T extends keyof CacheEntryTypes>(type: T, key: string) {\n    return (this.#caches[type].get(key) as CacheEntryTypes[T]) ?? null;\n  }\n\n  protected async set<T extends keyof CacheEntryTypes>(\n    type: T,\n    key: string,\n    value: CacheEntryTypes[T],\n  ) {\n    (this.#caches[type] as Map<string, typeof value>).set(key, value as never);\n  }\n\n  protected async delete<T extends keyof CacheEntryTypes>(\n    type: T,\n    key: string,\n  ) {\n    this.#caches[type].delete(key);\n  }\n\n  async clear<T extends keyof CacheEntryTypes>(type?: T) {\n    if (type) {\n      this.#caches[type].clear();\n    } else {\n      for (const cache of Object.values(this.#caches)) {\n        cache.clear();\n      }\n    }\n  }\n}\n\nexport interface ObjectCacheOptions {\n  cache?: AsyncCache;\n  client: SuiClient;\n  onEffects?: (\n    effects: typeof bcs.TransactionEffects.$inferType,\n  ) => Promise<void>;\n}\n\nexport class CustomObjectCache {\n  #client: SuiClient;\n  #cache: AsyncCache;\n  #onEffects?: (\n    effects: typeof bcs.TransactionEffects.$inferType,\n  ) => Promise<void>;\n\n  constructor({\n    cache = new InMemoryObjectCache(),\n    onEffects,\n    client,\n  }: ObjectCacheOptions) {\n    this.#client = client;\n    this.#cache = cache;\n    this.#onEffects = onEffects;\n  }\n\n  private async applyCache(\n    transactionData: TransactionDataBuilder,\n    unresolvedObjects: string[],\n  ) {\n    const cached = (await this.#cache.getObjects(unresolvedObjects)).filter(\n      (obj) => obj !== null,\n    );\n\n    const byId = new Map(cached.map((obj) => [obj!.objectId, obj]));\n    const unresolved: string[] = [];\n    for (const input of transactionData.inputs) {\n      if (!input.UnresolvedObject) {\n        continue;\n      }\n\n      const cached = byId.get(input.UnresolvedObject.objectId);\n\n      if (!cached) {\n        unresolved.push(input.UnresolvedObject.objectId);\n        continue;\n      }\n\n      if (\n        cached.initialSharedVersion &&\n        !input.UnresolvedObject.initialSharedVersion\n      ) {\n        input.UnresolvedObject.initialSharedVersion =\n          cached.initialSharedVersion;\n      } else {\n        if (cached.version && !input.UnresolvedObject.version) {\n          input.UnresolvedObject.version = cached.version;\n        }\n\n        if (cached.digest && !input.UnresolvedObject.digest) {\n          input.UnresolvedObject.digest = cached.digest;\n        }\n      }\n    }\n    return unresolved;\n  }\n\n  private async resolveObjects(\n    transactionData: TransactionDataBuilder,\n    unresolved: string[],\n  ) {\n    const unresolvedObjects = await this.applyCache(\n      transactionData,\n      unresolved,\n    );\n    if (unresolvedObjects.length === 0) {\n      return [];\n    }\n    const dedup = [...new Set(unresolvedObjects)];\n    const res = await this.#client.multiGetObjects({\n      ids: dedup,\n      options: {\n        showOwner: true,\n      },\n    });\n    const objects: ObjectCacheEntry[] = [];\n    for (const obj of res || []) {\n      if (!obj.data) {\n        continue;\n      }\n      const owner = obj.data.owner;\n\n      const initialSharedVersion =\n        owner && typeof owner === \"object\" && \"Shared\" in owner\n          ? owner.Shared.initial_shared_version\n          : null;\n      const ownerAddress =\n        owner && typeof owner === \"object\" && \"AddressOwner\" in owner\n          ? owner.AddressOwner\n          : null;\n      const cached: ObjectCacheEntry = {\n        objectId: obj.data.objectId,\n        version: obj.data.version,\n        digest: obj.data.digest,\n        initialSharedVersion,\n        owner: ownerAddress,\n      };\n      objects.push(cached);\n    }\n    await this.#cache.addObjects(objects);\n    return await this.applyCache(transactionData, unresolvedObjects);\n  }\n\n  asPlugin(): TransactionPlugin {\n    return async (transactionData, _options, next) => {\n      const unresolvedObjects = transactionData.inputs\n        .filter((input) => input.UnresolvedObject)\n        .map((input) => input.UnresolvedObject!.objectId);\n\n      // if object is not in cache yet, fetch from RPC and save to cache and resolve all objects\n      await this.resolveObjects(transactionData, unresolvedObjects);\n\n      await Promise.all(\n        transactionData.commands.map(async (commands) => {\n          if (commands.MoveCall) {\n            const def = await this.getMoveFunctionDefinition({\n              package: commands.MoveCall.package,\n              module: commands.MoveCall.module,\n              function: commands.MoveCall.function,\n            });\n\n            if (def) {\n              commands.MoveCall._argumentTypes = def.parameters;\n            }\n          }\n        }),\n      );\n\n      await next();\n\n      await Promise.all(\n        transactionData.commands.map(async (commands) => {\n          if (commands.MoveCall?._argumentTypes) {\n            await this.#cache.addMoveFunctionDefinition({\n              package: commands.MoveCall.package,\n              module: commands.MoveCall.module,\n              function: commands.MoveCall.function,\n              parameters: commands.MoveCall._argumentTypes,\n            });\n          }\n        }),\n      );\n    };\n  }\n\n  async clear() {\n    await this.#cache.clear();\n  }\n\n  async getMoveFunctionDefinition(ref: {\n    package: string;\n    module: string;\n    function: string;\n  }) {\n    return this.#cache.getMoveFunctionDefinition(ref);\n  }\n\n  async getObjects(ids: string[]) {\n    return this.#cache.getObjects(ids);\n  }\n\n  async deleteObjects(ids: string[]) {\n    return this.#cache.deleteObjects(ids);\n  }\n\n  async clearOwnedObjects() {\n    await this.#cache.clear(\"OwnedObject\");\n  }\n\n  async clearCustom() {\n    await this.#cache.clear(\"Custom\");\n  }\n\n  async getCustom<T>(key: string) {\n    return this.#cache.getCustom<T>(key);\n  }\n\n  async setCustom<T>(key: string, value: T) {\n    return this.#cache.setCustom(key, value);\n  }\n\n  async deleteCustom(key: string) {\n    return this.#cache.deleteCustom(key);\n  }\n\n  async applyEffects(effects: typeof bcs.TransactionEffects.$inferType) {\n    if (!effects.V2) {\n      throw new Error(\n        `Unsupported transaction effects version ${effects.$kind}`,\n      );\n    }\n\n    const { lamportVersion, changedObjects } = effects.V2;\n\n    const deletedIds: string[] = [];\n    const addedObjects: ObjectCacheEntry[] = [];\n\n    changedObjects.forEach(([id, change]) => {\n      if (change.outputState.NotExist) {\n        deletedIds.push(id);\n      } else if (change.outputState.ObjectWrite) {\n        const [digest, owner] = change.outputState.ObjectWrite;\n\n        addedObjects.push({\n          objectId: id,\n          digest,\n          version: lamportVersion,\n          owner: owner.AddressOwner ?? owner.ObjectOwner ?? null,\n          initialSharedVersion: owner.Shared?.initialSharedVersion ?? null,\n        });\n      }\n    });\n\n    await Promise.all([\n      this.#cache.addObjects(addedObjects),\n      this.#cache.deleteObjects(deletedIds),\n      this.#onEffects?.(effects),\n    ]);\n  }\n}\n"]}