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

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{a as u,b as y,c as C,d as Z,e as I,f as J,g as N,h as Q,i as x,j as D,l as m}from"./chunk-ETQEI4QC.mjs";import{getFullnodeUrl as Ft,SuiClient as pt}from"@mysten/sui/client";import{coinWithBalance as Nt,Transaction as Qt}from"@mysten/sui/transactions";import{normalizeStructTag as ut,toBase64 as Kt}from"@mysten/sui/utils";var tt="0x0000000000000000000000000000000000000000000000000000000000000000";import{normalizeSuiAddress as vt,parseStructTag as oe}from"@mysten/sui/utils";var St=["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000003","0x0000000000000000000000000000000000000000000000000000000000000004","0x0000000000000000000000000000000000000000000000000000000000000005","0x0000000000000000000000000000000000000000000000000000000000000006","0x0000000000000000000000000000000000000000000000000000000000000007","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000009","0x0000000000000000000000000000000000000000000000000000000000000403","0x000000000000000000000000000000000000000000000000000000000000000c"],v=s=>{let t=vt(s);return St.includes(t)};import{Transaction as At}from"@mysten/sui/transactions";import{normalizeSuiAddress as K}from"@mysten/sui/utils";var V=class{async getObject(t){let[e,r]=await Promise.all([this.get("OwnedObject",t),this.get("SharedOrImmutableObject",t)]);return 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=`${K(t.package)}::${t.module}::${t.function}`;return this.get("MoveFunction",e)}async addMoveFunctionDefinition(t){let e=K(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=`${K(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);y(this,h,{OwnedObject:new Map,SharedOrImmutableObject:new Map,MoveFunction:new Map,Custom:new Map})}async get(e,r){return u(this,h)[e].get(r)??null}async set(e,r,i){u(this,h)[e].set(r,i)}async delete(e,r){u(this,h)[e].delete(r)}async clear(e){if(e)u(this,h)[e].clear();else for(let r of Object.values(u(this,h)))r.clear()}};h=new WeakMap;var S,l,A,M=class{constructor({cache:t=new q,onEffects:e,client:r}){y(this,S);y(this,l);y(this,A);C(this,S,r),C(this,l,t),C(this,A,e)}async applyCache(t,e){let r=(await u(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 u(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 u(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=>{o.MoveCall?._argumentTypes&&await u(this,l).addMoveFunctionDefinition({package:o.MoveCall.package,module:o.MoveCall.module,function:o.MoveCall.function,parameters:o.MoveCall._argumentTypes})}))}}async clear(){await u(this,l).clear()}async getMoveFunctionDefinition(t){return u(this,l).getMoveFunctionDefinition(t)}async getObjects(t){return u(this,l).getObjects(t)}async deleteObjects(t){return u(this,l).deleteObjects(t)}async clearOwnedObjects(){await u(this,l).clear("OwnedObject")}async clearCustom(){await u(this,l).clear("Custom")}async getCustom(t){return u(this,l).getCustom(t)}async setCustom(t,e){return u(this,l).setCustom(t,e)}async deleteCustom(t){return u(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:g.AddressOwner??g.ObjectOwner??null,initialSharedVersion:g.Shared?.initialSharedVersion??null})}}),await Promise.all([u(this,l).addObjects(o),u(this,l).deleteObjects(i),(n=u(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;y(this,T);this.devInspectTransactionBlock=async t=>{t.transactionBlock instanceof At&&t.transactionBlock.addBuildPlugin(u(this,T).asPlugin());try{return await this.client.devInspectTransactionBlock(t)}catch(e){throw await u(this,T).clear(),e}finally{await u(this,T).clearOwnedObjects()}};C(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)}};import{coinWithBalance as Et,Transaction as _t}from"@mysten/sui/transactions";var X=async(s,t,e)=>{let r=await G(()=>t.devInspectTransactionBlock({sender:e.sender,transactionBlock:s}),e.timeout??2e3);if(r.effects.status.status==="failure")throw new m(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 _t,n=await s.swap({quote:t,coinIn:Et({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:`${N}::vault::collect_tip`,typeArguments:[s.coinTypeOut],arguments:[n.object(x),n.object(D),t,n.pure.u64(r)]}),n.moveCall({target:`${N}::settle::settle`,typeArguments:[s.coinTypeIn,s.coinTypeOut],arguments:[n.object(D),n.object(x),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=>s.filter(e=>e.type===`${Q}::settle::Swap`)?.pop()?.parsedJson?.amount_out,G=async(s,t,e)=>t<=0?s():new Promise((r,i)=>{let o=setTimeout(()=>i(new m(`Timeout ${e??"operation"}`,1001,{timeout:t})),t);s().then(r).catch(i).finally(()=>clearTimeout(o))});import{Commands as xt,Transaction as it,TransactionDataBuilder as Dt}from"@mysten/sui/transactions";import{normalizeStructTag as Mt,normalizeSuiAddress as nt,toBase64 as kt}from"@mysten/sui/utils";import{v4 as jt}from"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=Mt(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=`${this.options.api??Lt}${ot}${n}`,p=await(await fetch(a,{headers:await Bt(this.options,"GET",ot,n)})).json();return m.assert(p.code==="0"&&p.data.length>0,"No quote found",1005,{provider:this.kind}),{id:jt(),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;m.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(kt(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 m("Base64 encoder not available in this environment")};if(typeof globalThis<"u"&&globalThis.crypto?.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 import("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 m("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=Dt.restore(s.getData()),r=e.commands.findIndex(n=>n.$kind==="MoveCall"&&nt(n.MoveCall.package)===nt(t)&&n.MoveCall.module==="router"&&n.MoveCall.function==="finalize"),i=e.commands[r];return m.assert(i.MoveCall,"OKX: Finalize command not found",1100,{packageId:t}),e.replaceCommand(r,xt.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:it.from(e.build()),coin:{NestedResult:[r,0]}}},at=s=>{let{quote:t,signer:e}=s;m.assert(t.provider==="okx","Invalid quote",1004,{quote:t,expectedProvider:"okx"});let r=it.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=class{constructor(t){this.providers={};this.options={providers:{...qt,...t?.providers},slippageBps:t?.slippageBps??100,fullnodeUrl:t?.fullnodeUrl??Ft("mainnet"),hermesApi:t?.hermesApi??Vt,partner:t?.partner??tt,partnerCommissionBps:t?.partnerCommissionBps??0,tipBps:t?.tipBps??0},this.client=new pt({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(m.assert(!!r,`Provider not found: ${t}`,1002,{provider:t}),t){case"bluefin7k":let{Bluefin7kProvider:i}=await import("./bluefin7k-TERLUCNL.mjs").catch(W("bluefin7k"));this.providers.bluefin7k=new i(r,this.options,this.client);break;case"flowx":let{FlowxProvider:o}=await import("./flowx-OXZZX5FD.mjs").catch(W("flowx"));this.providers.flowx=new o(r,this.client);break;case"cetus":let{CetusProvider:n}=await import("./cetus-AU3OMWOY.mjs").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 m(`Provider not supported: ${t}`,1003,{provider:t})}return this.providers[t]}async _simulate(t,e,r){try{if(I(t))return rt(t,e,r,this.inspector,this.options);if(e.provider==="okx")return ct(e,this.inspector,r,this.options);throw new m(`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},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 Qt,a=await this.swap({quote:t,signer:e,tx:n,coinIn:Nt({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(Kt(c));return this.client.executeTransactionBlock({transactionBlock:g,signature:p,options:o?.options,signal:o?.signal})}async quote(t,e){let r={...t,coinTypeIn:ut(t.coinTypeIn),coinTypeOut:ut(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=p?.simulatedAmountOut,a.gasUsed=p?.gasUsed,e?.onSimulated?.({...a})});e.onSimulated||await Promise.all(n)}return o}async swap(t,e){let r=await this._getProvider(t.quote.provider);m.assert(!!r,`Provider not found: ${t.quote.provider}`,1002,{provider:t.quote.provider}),m.assert(I(r),`Provider does not support swap: ${r.kind}, use fastSwap instead`,1007,{provider:r.kind}),m.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,e??this.options.slippageBps??100,this.options.tipBps,this.options.partner,this.options.partnerCommissionBps)),t.tx.setSenderIfNotSet(t.signer),i}async fastSwap(t,e){m.assert(t.signer&&!v(t.signer),"Invalid signer address",1006,{signer:t.signer});let r=await this._getProvider(t.quote.provider);if(I(r))return this._fastSwap(t,e);if(J(r))return this.client.waitForTransaction({...e,digest:await r.fastSwap(t)});throw new m(`Provider not supported: ${r.kind}`,1003,{provider:r.kind})}updateMetaAgOptions(t){if(Object.keys(t).length!==0){this.options.slippageBps=t.slippageBps??this.options.slippageBps,this.options.partner=t.partner??this.options.partner,this.options.partnerCommissionBps=t.partnerCommissionBps??this.options.partnerCommissionBps,this.options.tipBps=t.tipBps??this.options.tipBps,t.fullnodeUrl&&t.fullnodeUrl!==this.options.fullnodeUrl&&(this.client=new pt({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(t?.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{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{return s.slice(0,mt).reduce((e,r)=>(e[B(r)]=0,e),{})}}async function lt(){return await z(j)}import{coinWithBalance as zt,Transaction as Ht}from"@mysten/sui/transactions";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 Ht,p=c.add(zt({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}import{Transaction as Yt}from"@mysten/sui/transactions";async function gt({orderId:s,payCoinType:t,targetCoinType:e}){let r=new Yt;return r.moveCall({target:`${b}::cancel_limit_order`,typeArguments:[t,e],arguments:[r.object(s),r.object.clock()]}),r}import{Transaction as Zt}from"@mysten/sui/transactions";async function ft({orderId:s,payCoinType:t,targetCoinType:e}){let r=new Zt;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()}import{coinWithBalance as Jt,Transaction as te}from"@mysten/sui/transactions";async function yt({payCoinType:s,targetCoinType:t,payCoinAmountEach:e,numOrders:r,interval:i,slippage:o,minRate:n,maxRate:a}){let c=new te,p=[];for(let _=0;_<r;_++){let bt=Jt({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}import{Transaction as ee}from"@mysten/sui/transactions";async function Tt({orderId:s,payCoinType:t,targetCoinType:e}){let r=new ee;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};export{Z as EProvider,U as MetaAg,Tt as cancelDcaOrder,gt as cancelLimitOrder,ft as claimExpiredLimitOrder,An as default,Pt as getClosedDcaOrders,ht as getClosedLimitOrders,wt as getDcaOrderExecutions,Ct as getOpenDcaOrders,Ot as getOpenLimitOrders,lt as getSuiPrice,z as getTokenPrice,H as getTokenPrices,I as isAggregatorProvider,J as isSwapAPIProvider,yt as placeDcaOrder,dt as placeLimitOrder};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/features/metaAg/index.ts","../src/constants/sui.ts","../src/utils/sui.ts","../src/utils/SuiClientUtils.ts","../src/utils/ObjectCache.ts","../src/utils/swap.ts","../src/features/metaAg/common.ts","../src/features/metaAg/providers/okx.ts","../src/constants/tokens.ts","../src/config/fetchClient.ts","../src/constants/apiEndpoints.ts","../src/utils/token.ts","../src/features/prices/index.ts","../src/features/limitDca/placeLimitOrder.ts","../src/features/limitDca/constants.ts","../src/features/limitDca/cancelLimitOrder.ts","../src/features/limitDca/claimExpiredLimitOrder.ts","../src/libs/url.ts","../src/features/limitDca/getOpenLimitOrders.ts","../src/features/limitDca/getClosedLimitOrders.ts","../src/features/limitDca/placeDcaOrder.ts","../src/features/limitDca/cancelDcaOrder.ts","../src/features/limitDca/getOpenDcaOrders.ts","../src/features/limitDca/getClosedDcaOrders.ts","../src/features/limitDca/getDcaOrderExecutions.ts","../src/index.ts"],"sourcesContent":["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","/**\n * Calculate expected return amount after applying slippage, commission, and tip\n * @param returnAmount - The raw return amount (with decimals)\n * @param slippageBps - Slippage in basis points (1 bps = 0.01%)\n * @param commissionBps - Commission in basis points\n * @param tipBps - Tip in basis points (default: 0)\n * @returns Object containing tipAmount, minAmount, commissionAmount, and expectedAmount\n */\nexport const getExpectedReturn = (\n  returnAmount: string,\n  slippageBps: number,\n  commissionBps: number,\n  tipBps: number = 0,\n) => {\n  if (slippageBps > 10000) {\n    throw new Error(\"Slippage must be less than 100%\");\n  }\n  if (commissionBps > 10000) {\n    throw new Error(\"Commission must be less than 100%\");\n  }\n  if (tipBps > 10000) {\n    throw new Error(\"Tip must be less than 100%\");\n  }\n  const returnAmountWithDecimal = BigInt(returnAmount);\n  const tipAmountWithDecimal =\n    (returnAmountWithDecimal * BigInt(tipBps || 0)) / 10000n;\n  const commissionAmountWithDecimal =\n    ((returnAmountWithDecimal - tipAmountWithDecimal) * BigInt(commissionBps)) /\n    10000n;\n  const expectedReturnWithDecimal =\n    returnAmountWithDecimal -\n    tipAmountWithDecimal -\n    commissionAmountWithDecimal;\n  const minAmountWithDecimal =\n    (expectedReturnWithDecimal * BigInt(1e4 - slippageBps)) / 10000n;\n\n  return {\n    tipAmount: tipAmountWithDecimal,\n    minAmount: minAmountWithDecimal,\n    commissionAmount: commissionAmountWithDecimal,\n    expectedAmount: expectedReturnWithDecimal.toString(10),\n  };\n};\n","import { SuiEvent } from \"@mysten/sui/client\";\nimport {\n  coinWithBalance,\n  Transaction,\n  TransactionObjectArgument,\n} from \"@mysten/sui/transactions\";\nimport {\n  _7K_META_CONFIG,\n  _7K_META_PACKAGE_ID,\n  _7K_META_PUBLISHED_AT,\n  _7K_META_VAULT,\n} from \"../../constants/_7k\";\nimport {\n  AggregatorProvider,\n  MetaAgOptions,\n  MetaQuote,\n  MetaSimulationOptions,\n} from \"../../types/metaAg\";\nimport { SuiClientUtils } from \"../../utils/SuiClientUtils\";\nimport { getExpectedReturn } from \"../../utils/swap\";\nimport { MetaAgError, MetaAgErrorCode } from \"./error\";\n\nexport const simulateSwapTx = async (\n  tx: Transaction,\n  inspector: SuiClientUtils,\n  simulation: MetaSimulationOptions,\n) => {\n  const res = await timeout(\n    () =>\n      inspector.devInspectTransactionBlock({\n        sender: simulation.sender,\n        transactionBlock: tx,\n      }),\n    simulation.timeout ?? 2000,\n  );\n  if (res.effects.status.status === \"failure\") {\n    throw new MetaAgError(\n      res.error ?? \"Simulation failed\",\n      MetaAgErrorCode.SIMULATION_FAILED,\n      { error: res.error },\n    );\n  }\n  const amountOut = extractAmountOutWrapper(res.events);\n  return {\n    simulatedAmountOut: amountOut as string,\n    gasUsed: res.effects.gasUsed,\n  };\n};\nexport const simulateAggregator = async (\n  provider: AggregatorProvider,\n  quote: MetaQuote,\n  simulation: MetaSimulationOptions,\n  inspector: SuiClientUtils,\n  options: Required<MetaAgOptions>,\n) => {\n  const tx = new Transaction();\n  const coinOut = await provider.swap({\n    quote,\n    coinIn: coinWithBalance({\n      balance: BigInt(quote.amountIn),\n      type: quote.coinTypeIn,\n      useGasCoin: false,\n    }),\n    signer: simulation.sender,\n    tx,\n  });\n  tx.add(\n    metaSettle(\n      quote,\n      coinOut,\n      10000,\n      options.tipBps,\n      options.partner,\n      options.partnerCommissionBps,\n    ),\n  );\n  tx.transferObjects([coinOut], simulation.sender);\n  const res = await simulateSwapTx(tx, inspector, simulation);\n  return {\n    id: quote.id,\n    provider: provider.kind,\n    ...res,\n  };\n};\n\n/**\n * this settlement does not charge commission fee for partner, since all integrated aggregators already charge commission fee for partner\n * @param quote Meta Aggregator Quote\n * @param coinOut Coin Out Object\n * @param slippageBps Slippage Bps\n * @param tipBps Tip Bps default = 0\n * @param partner address of partner for analytic default is zero address\n */\nexport const metaSettle = (\n  quote: MetaQuote,\n  coinOut: TransactionObjectArgument,\n  slippageBps = 100,\n  tipBps = 0,\n  partner?: string,\n  commissionBps = 0,\n) => {\n  return (tx: Transaction) => {\n    const { minAmount, expectedAmount } = getExpectedReturn(\n      quote.rawAmountOut,\n      slippageBps,\n      commissionBps,\n      tipBps,\n    );\n\n    if (tipBps > 0) {\n      tx.moveCall({\n        target: `${_7K_META_PUBLISHED_AT}::vault::collect_tip`,\n        typeArguments: [quote.coinTypeOut],\n        arguments: [\n          tx.object(_7K_META_VAULT),\n          tx.object(_7K_META_CONFIG),\n          coinOut,\n          tx.pure.u64(tipBps),\n        ],\n      });\n    }\n\n    tx.moveCall({\n      target: `${_7K_META_PUBLISHED_AT}::settle::settle`,\n      typeArguments: [quote.coinTypeIn, quote.coinTypeOut],\n      arguments: [\n        tx.object(_7K_META_CONFIG),\n        tx.object(_7K_META_VAULT),\n        tx.pure.u64(quote.amountIn),\n        coinOut,\n        tx.pure.u64(minAmount),\n        tx.pure.u64(expectedAmount),\n        tx.pure.option(\"address\", partner),\n        tx.pure.u64(commissionBps),\n        tx.pure.u64(0), // ps\n      ],\n    });\n  };\n};\n\nconst extractAmountOutWrapper = (events: SuiEvent[]) => {\n  const swapEvent = events\n    .filter((event) => event.type === `${_7K_META_PACKAGE_ID}::settle::Swap`)\n    ?.pop();\n  return (swapEvent?.parsedJson as any)?.amount_out;\n};\n\nexport const timeout = async <T = any>(\n  fn: () => Promise<T>,\n  timeout: number,\n  msg?: string,\n) => {\n  if (timeout <= 0) return fn();\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(\n      () =>\n        reject(\n          new MetaAgError(\n            `Timeout ${msg ?? \"operation\"}`,\n            MetaAgErrorCode.TIMEOUT,\n            { timeout },\n          ),\n        ),\n      timeout,\n    );\n    fn()\n      .then(resolve)\n      .catch(reject)\n      .finally(() => clearTimeout(timer));\n  });\n};\n","import { SuiClient } from \"@mysten/sui/client\";\nimport {\n  Commands,\n  Transaction,\n  TransactionDataBuilder,\n  TransactionObjectArgument,\n} from \"@mysten/sui/transactions\";\nimport {\n  normalizeStructTag,\n  normalizeSuiAddress,\n  toBase64,\n} from \"@mysten/sui/utils\";\nimport { v4 } from \"uuid\";\nimport { SUI_TYPE } from \"../../../constants/tokens\";\nimport {\n  EProvider,\n  MetaAgOptions,\n  MetaFastSwapOptions,\n  MetaQuote,\n  MetaQuoteOptions,\n  MetaSimulationOptions,\n  MetaSwapOptions,\n  OkxProviderOptions,\n  QuoteProvider,\n  SwapAPIProvider,\n} from \"../../../types/metaAg\";\nimport { OkxSwapRequest, OkxSwapResponse } from \"../../../types/okx\";\nimport { isSystemAddress } from \"../../../utils/sui\";\nimport { SuiClientUtils } from \"../../../utils/SuiClientUtils\";\nimport { metaSettle, simulateSwapTx } from \"../common\";\nimport { MetaAgError, MetaAgErrorCode } from \"../error\";\n\nconst API = \"https://web3.okx.com\";\nconst SWAP_PATH = \"/api/v6/dex/aggregator/swap\";\nconst CHAIN_ID = \"784\";\nconst NORMALIZED_SUI_TYPE = normalizeStructTag(SUI_TYPE);\nexport class OkxProvider implements QuoteProvider, SwapAPIProvider {\n  readonly kind = EProvider.OKX;\n  constructor(\n    private readonly options: OkxProviderOptions,\n    private readonly metaOptions: Required<MetaAgOptions>,\n    private readonly client: SuiClient,\n  ) {}\n\n  async quote({\n    amountIn,\n    coinTypeIn,\n    coinTypeOut,\n    signer,\n  }: MetaQuoteOptions): Promise<MetaQuote | null> {\n    if (!signer || isSystemAddress(signer)) return null;\n    const request: OkxSwapRequest = {\n      chainIndex: CHAIN_ID,\n      amount: amountIn,\n      fromTokenAddress:\n        coinTypeIn === NORMALIZED_SUI_TYPE ? SUI_TYPE : coinTypeIn,\n      toTokenAddress:\n        coinTypeOut === NORMALIZED_SUI_TYPE ? SUI_TYPE : coinTypeOut,\n      slippagePercent: (this.metaOptions.slippageBps / 100).toString(),\n      userWalletAddress: signer,\n    };\n    const queryString = \"?\" + new URLSearchParams(request as any).toString();\n    const url = `${this.options.api ?? API}${SWAP_PATH}${queryString}`;\n    const response = await fetch(url, {\n      headers: await getHeaders(this.options, \"GET\", SWAP_PATH, queryString),\n    });\n    const quote = (await response.json()) as OkxSwapResponse;\n    MetaAgError.assert(\n      quote.code === \"0\" && quote.data.length > 0,\n      \"No quote found\",\n      MetaAgErrorCode.QUOTE_NOT_FOUND,\n      { provider: this.kind },\n    );\n    return {\n      id: v4(),\n      provider: this.kind,\n      coinTypeIn,\n      coinTypeOut,\n      amountIn,\n      amountOut: quote.data[0].routerResult.toTokenAmount,\n      rawAmountOut: quote.data[0].routerResult.toTokenAmount,\n      quote: quote.data[0],\n    };\n  }\n\n  async fastSwap(options: MetaFastSwapOptions): Promise<string> {\n    const { quote, signer, signTransaction } = options;\n    MetaAgError.assert(\n      quote.provider === EProvider.OKX,\n      \"Invalid quote\",\n      MetaAgErrorCode.INVALID_QUOTE,\n      { quote, expectedProvider: EProvider.OKX },\n    );\n    const { tx, coin } = buildTx({ quote, signer });\n    tx.add(\n      metaSettle(\n        quote,\n        coin,\n        this.metaOptions.slippageBps,\n        this.metaOptions.tipBps,\n        this.metaOptions.partner,\n        this.metaOptions.partnerCommissionBps,\n      ),\n    );\n    tx.transferObjects([coin], signer);\n    const txBytes = await tx.build({ client: this.client });\n    const { bytes, signature } = await signTransaction(toBase64(txBytes));\n    const res = await this.client.executeTransactionBlock({\n      signature,\n      transactionBlock: bytes,\n    });\n    return res.digest;\n  }\n}\n\nasync function generateHmacSha256(message: string, secretKey: string) {\n  const encoder = new TextEncoder();\n  const encodeBase64 = (bytes: Uint8Array) => {\n    if (typeof Buffer !== \"undefined\") {\n      return Buffer.from(bytes).toString(\"base64\");\n    }\n    let binary = \"\";\n    for (let i = 0; i < bytes.byteLength; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }\n    if (typeof btoa !== \"undefined\") {\n      return btoa(binary);\n    }\n    throw new MetaAgError(\"Base64 encoder not available in this environment\");\n  };\n\n  if (typeof globalThis !== \"undefined\" && globalThis.crypto?.subtle) {\n    const key = await globalThis.crypto.subtle.importKey(\n      \"raw\",\n      encoder.encode(secretKey),\n      { name: \"HMAC\", hash: \"SHA-256\" },\n      false,\n      [\"sign\"],\n    );\n    const signature = await globalThis.crypto.subtle.sign(\n      \"HMAC\",\n      key,\n      encoder.encode(message),\n    );\n    return encodeBase64(new Uint8Array(signature));\n  }\n\n  const { createHmac } = await import(\"node:crypto\");\n  return createHmac(\"sha256\", secretKey).update(message).digest(\"base64\");\n}\n\nasync function getHeaders(\n  options: OkxProviderOptions,\n  method: string,\n  requestPath: string,\n  queryString = \"\",\n) {\n  const { apiKey, secretKey, apiPassphrase, projectId } = options;\n  if (!apiKey || !secretKey || !apiPassphrase || !projectId) {\n    throw new MetaAgError(\"Missing required environment variables\");\n  }\n\n  const timestamp = new Date().toISOString();\n  const stringToSign = timestamp + method + requestPath + queryString;\n  return {\n    \"Content-Type\": \"application/json\",\n    \"OK-ACCESS-KEY\": apiKey,\n    \"OK-ACCESS-SIGN\": await generateHmacSha256(stringToSign, secretKey),\n    \"OK-ACCESS-TIMESTAMP\": timestamp,\n    \"OK-ACCESS-PASSPHRASE\": apiPassphrase,\n    \"OK-ACCESS-PROJECT\": projectId,\n  };\n}\n\nconst replaceFinalizeCommand = (\n  tx: Transaction,\n  packageId: string,\n): { tx: Transaction; coin: TransactionObjectArgument } => {\n  const builder = TransactionDataBuilder.restore(tx.getData());\n  const i = builder.commands.findIndex(\n    (cmd) =>\n      cmd.$kind === \"MoveCall\" &&\n      normalizeSuiAddress(cmd.MoveCall.package) ===\n        normalizeSuiAddress(packageId) &&\n      cmd.MoveCall.module === \"router\" &&\n      cmd.MoveCall.function === \"finalize\",\n  );\n\n  const cmd = builder.commands[i];\n  MetaAgError.assert(\n    cmd.MoveCall,\n    \"OKX: Finalize command not found\",\n    MetaAgErrorCode.OKX_FINALIZE_COMMAND_NOT_FOUND,\n    { packageId },\n  );\n  builder.replaceCommand(\n    i,\n    Commands.MoveCall({\n      package: packageId,\n      module: \"router\",\n      function: \"finalize_without_transfer\",\n      typeArguments: cmd.MoveCall.typeArguments,\n      arguments: [\n        cmd.MoveCall.arguments[0],\n        cmd.MoveCall.arguments[5],\n        cmd.MoveCall.arguments[6],\n      ],\n    }),\n  );\n  const tx2 = Transaction.from(builder.build());\n  return { tx: tx2, coin: { NestedResult: [i, 0] } };\n};\n\nconst buildTx = (options: Omit<MetaSwapOptions, \"coinIn\" | \"tx\">) => {\n  const { quote, signer } = options;\n  MetaAgError.assert(\n    quote.provider === EProvider.OKX,\n    \"Invalid quote\",\n    MetaAgErrorCode.INVALID_QUOTE,\n    { quote, expectedProvider: EProvider.OKX },\n  );\n  const tx = Transaction.from(quote.quote.tx.data);\n  tx.setSenderIfNotSet(signer);\n  const { tx: tx2, coin } = replaceFinalizeCommand(tx, quote.quote.tx.to);\n\n  return { tx: tx2, coin };\n};\n\nexport const simulateOKXSwap = async <\n  T extends MetaQuote & { provider: EProvider.OKX },\n>(\n  quote: T,\n  inspector: SuiClientUtils,\n  simulation: MetaSimulationOptions,\n  metaOptions: Required<MetaAgOptions>,\n) => {\n  const { tx, coin } = buildTx({ quote, signer: quote.quote.tx.from });\n  tx.add(\n    metaSettle(\n      quote,\n      coin,\n      10000,\n      metaOptions.tipBps,\n      metaOptions.partner,\n      metaOptions.partnerCommissionBps,\n    ),\n  );\n  tx.transferObjects([coin], quote.quote.tx.from);\n  const res = await simulateSwapTx(tx, inspector, simulation);\n  return {\n    id: quote.id,\n    provider: quote.provider,\n    ...res,\n  };\n};\n","export const SUI_TYPE = \"0x2::sui::SUI\";\n\nexport const SUI_FULL_TYPE =\n  \"0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI\";\n\nexport const USDC_TOKEN_TYPE =\n  \"0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN\";\n\nexport const NATIVE_USDC_TOKEN_TYPE =\n  \"0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC\";\n","export async function fetchClient(\n  input: string,\n  init?: RequestInit,\n): Promise<Response> {\n  const headers = new Headers(init?.headers);\n\n  // intercept the request and add the headers go here...\n  const modifiedInit: RequestInit = {\n    ...init,\n    headers,\n  };\n\n  return fetch(input, modifiedInit);\n}\n","export const API_ENDPOINTS = {\n  MAIN: \"https://api.7k.ag\",\n  LO_DCA: \"https://lod-dca.7k.ag\",\n  PRICES: \"https://lp-pro-api.7k.ag/price\",\n  STATISTIC: \"https://statistic.7k.ag\",\n};\n","import { SUI_FULL_TYPE, SUI_TYPE } from \"../constants/tokens\";\n\nexport function normalizeTokenType(type: string) {\n  return type === SUI_TYPE ? SUI_FULL_TYPE : type;\n}\n\nexport function denormalizeTokenType(type: string) {\n  return type === SUI_FULL_TYPE ? SUI_TYPE : type;\n}\n\nexport function checkIsSui(type: string) {\n  return type === SUI_FULL_TYPE || type === SUI_TYPE;\n}\n","import { fetchClient } from \"../../config/fetchClient\";\nimport { API_ENDPOINTS } from \"../../constants/apiEndpoints\";\nimport { SUI_FULL_TYPE } from \"../../constants/tokens\";\nimport { normalizeTokenType } from \"../../utils/token\";\n\n/**\n * Response structure from the new price service API\n */\ninterface TokenPriceResponse {\n  token_id: string;\n  timestamp: number;\n  price: number;\n}\n\n/**\n * Request structure for the batch price API\n */\ninterface BatchPriceRequest {\n  timestamp: string; // Unix timestamp as string\n  token_ids: string[];\n}\n\nconst chunkArray = <T>(array: T[], chunkSize: number): T[][] => {\n  const chunks: T[][] = [];\n  for (let i = 0; i < array.length; i += chunkSize) {\n    chunks.push(array.slice(i, i + chunkSize));\n  }\n  return chunks;\n};\n\nconst MAX_TOTAL_IDS = 500;\nconst MAX_IDS_PER_REQUEST = 100;\n\n/**\n * Get the current Unix timestamp as a string\n */\nfunction getCurrentTimestamp(): string {\n  return Math.floor(Date.now() / 1000).toString();\n}\n\n/**\n * Get price for a single token\n * @param id - Token ID (coin type)\n * @returns Token price, or 0 if not found or on error\n */\nexport async function getTokenPrice(id: string): Promise<number> {\n  try {\n    const normalizedId = normalizeTokenType(id);\n    const prices = await getTokenPrices([normalizedId]);\n    return prices[normalizedId] || 0;\n  } catch (_) {\n    return 0;\n  }\n}\n\n/**\n * Get prices for multiple tokens\n * @param ids - Array of token IDs (coin types)\n * @returns Record mapping token IDs to their prices\n */\nexport async function getTokenPrices(\n  ids: string[],\n): Promise<Record<string, number>> {\n  try {\n    if (ids.length === 0) {\n      return {};\n    }\n\n    const limitedIds = ids.slice(0, MAX_TOTAL_IDS).map(normalizeTokenType);\n    const idChunks = chunkArray(limitedIds, MAX_IDS_PER_REQUEST);\n    const timestamp = getCurrentTimestamp();\n\n    const responses = await Promise.all(\n      idChunks.map(async (chunk) => {\n        const requestBody: BatchPriceRequest = {\n          timestamp,\n          token_ids: chunk,\n        };\n\n        const response = await fetchClient(\n          `${API_ENDPOINTS.PRICES}/prices/batch`,\n          {\n            method: \"POST\",\n            headers: {\n              \"Content-Type\": \"application/json\",\n            },\n            body: JSON.stringify(requestBody),\n          },\n        );\n\n        if (!response.ok) {\n          throw new Error(`Price API returned status ${response.status}`);\n        }\n\n        const pricesRes = (await response.json()) as TokenPriceResponse[];\n        return pricesRes;\n      }),\n    );\n\n    // Combine all responses into a single record\n    const combinedPrices = responses.reduce(\n      (acc, priceResponses) => {\n        priceResponses.forEach((priceResponse) => {\n          acc[priceResponse.token_id] = priceResponse.price;\n        });\n        return acc;\n      },\n      {} as Record<string, number>,\n    );\n\n    // Ensure all requested IDs are in the result (set to 0 if not found)\n    const finalPrices = limitedIds.reduce(\n      (acc, id) => {\n        acc[id] = combinedPrices[id] || 0;\n        return acc;\n      },\n      {} as Record<string, number>,\n    );\n\n    return finalPrices;\n  } catch (_) {\n    // On error, return 0 for all requested IDs\n    return ids.slice(0, MAX_TOTAL_IDS).reduce(\n      (acc, id) => {\n        acc[normalizeTokenType(id)] = 0;\n        return acc;\n      },\n      {} as Record<string, number>,\n    );\n  }\n}\n\n/**\n * Get the current SUI token price\n * @returns SUI price, or 0 if not found or on error\n */\nexport async function getSuiPrice(): Promise<number> {\n  return await getTokenPrice(SUI_FULL_TYPE);\n}\n","import { coinWithBalance, Transaction } from \"@mysten/sui/transactions\";\nimport { GLOBAL_CONFIG_ID, LIMIT_ORDER_MODULE_ID } from \"./constants\";\n\nexport interface PlaceLimitOrderParams {\n  accountAddress: string;\n  payCoinType: string;\n  targetCoinType: string;\n  payCoinAmount: bigint;\n  rate: bigint;\n  slippage: bigint;\n  expireTs: bigint;\n  devInspect?: boolean;\n}\n\nexport async function placeLimitOrder({\n  accountAddress,\n  payCoinType,\n  targetCoinType,\n  payCoinAmount,\n  rate,\n  slippage,\n  expireTs,\n  devInspect,\n}: PlaceLimitOrderParams) {\n  const tx = new Transaction();\n  const payCoin = tx.add(\n    coinWithBalance({\n      type: payCoinType,\n      balance: payCoinAmount,\n      useGasCoin: !devInspect,\n    }),\n  );\n\n  tx.moveCall({\n    target: `${LIMIT_ORDER_MODULE_ID}::place_limit_order`,\n    arguments: [\n      tx.object(GLOBAL_CONFIG_ID),\n      payCoin,\n      tx.pure.u64(rate),\n      tx.pure.u64(slippage),\n      tx.pure.u64(expireTs),\n      tx.object.clock(),\n    ],\n    typeArguments: [payCoinType, targetCoinType],\n  });\n\n  tx.setSenderIfNotSet(accountAddress);\n  return tx;\n}\n","import { API_ENDPOINTS } from \"../../constants/apiEndpoints\";\n\nexport const GLOBAL_CONFIG_ID =\n  \"0xffc7f420b481ed7a012b42e125fd7e5716b5673759cf4629e5fcfebce970a72d\";\nexport const RATE_SCALE = BigInt(\"1000000000000\");\nexport const SLIPPAGE_SCALE = BigInt(\"10000\");\nexport const PACKAGE =\n  \"0x0ef0f805710cf53c10f29c4f73e1144a662747e1839689a846e2520cae122adc\";\nexport const LIMIT_ORDER_MODULE_ID = `${PACKAGE}::limit_order`;\nexport const DCA_ORDER_MODULE_ID = `${PACKAGE}::dca_order`;\nexport const CONFIG_MODULE_ID = `${PACKAGE}::config`;\nexport const DCA_MAX_RATE = BigInt(\"18446744073709551615\");\nexport const LO_DCA_API = `${API_ENDPOINTS.LO_DCA}/api`;\n","import { Transaction } from \"@mysten/sui/transactions\";\nimport { LIMIT_ORDER_MODULE_ID } from \"./constants\";\n\ninterface CancelLimitOrderParams {\n  orderId: string;\n  payCoinType: string;\n  targetCoinType: string;\n}\n\nexport async function cancelLimitOrder({\n  orderId,\n  payCoinType,\n  targetCoinType,\n}: CancelLimitOrderParams) {\n  const tx = new Transaction();\n\n  tx.moveCall({\n    target: `${LIMIT_ORDER_MODULE_ID}::cancel_limit_order`,\n    typeArguments: [payCoinType, targetCoinType],\n    arguments: [tx.object(orderId), tx.object.clock()],\n  });\n\n  return tx;\n}\n","import { Transaction } from \"@mysten/sui/transactions\";\nimport { LIMIT_ORDER_MODULE_ID } from \"./constants\";\n\ninterface ClaimExpiredLimitOrderParams {\n  orderId: string;\n  payCoinType: string;\n  targetCoinType: string;\n}\n\nexport async function claimExpiredLimitOrder({\n  orderId,\n  payCoinType,\n  targetCoinType,\n}: ClaimExpiredLimitOrderParams) {\n  const tx = new Transaction();\n\n  tx.moveCall({\n    target: `${LIMIT_ORDER_MODULE_ID}::claim_expired_order`,\n    typeArguments: [payCoinType, targetCoinType],\n    arguments: [tx.object(orderId), tx.object.clock()],\n  });\n\n  return tx;\n}\n","export function formatQueryParams(params: Record<string, any>) {\n  let str = \"\";\n  Object.entries(params).forEach(([key, value]) => {\n    if (Array.isArray(value)) {\n      for (const v of value) {\n        str += str ? `&${key}=${v}` : `${key}=${v}`;\n      }\n    } else if (value !== undefined) {\n      str += str ? `&${key}=${value}` : `${key}=${value}`;\n    }\n  });\n  return str;\n}\n","import { fetchClient } from \"../../config/fetchClient\";\nimport { formatQueryParams } from \"../../libs/url\";\nimport { LO_DCA_API } from \"./constants\";\nimport { LimitOrder, LoDcaQueryParams } from \"./types\";\n\ninterface Params {\n  owner: string;\n  offset: number;\n  limit: number;\n  tokenPair?: string;\n}\n\nexport async function getOpenLimitOrders({\n  owner,\n  offset = 0,\n  limit = 10,\n  tokenPair,\n}: Params) {\n  const queryParams: LoDcaQueryParams = {\n    owner,\n    statuses: [\"ACTIVE\", \"EXPIRED\"],\n    offset,\n    limit,\n    tokenPair,\n  };\n  const paramsStr = formatQueryParams(queryParams);\n\n  const response = await fetchClient(`${LO_DCA_API}/limit-orders?${paramsStr}`);\n\n  if (!response.ok) {\n    throw new Error(\"Failed to fetch open limit orders\");\n  }\n\n  const orders = (await response.json()) as LimitOrder[];\n  return orders;\n}\n","import { fetchClient } from \"../../config/fetchClient\";\nimport { formatQueryParams } from \"../../libs/url\";\nimport { LO_DCA_API } from \"./constants\";\nimport { LimitOrder, LoDcaQueryParams } from \"./types\";\n\ninterface Params {\n  owner: string;\n  offset: number;\n  limit: number;\n  tokenPair?: string;\n}\n\nexport async function getClosedLimitOrders({\n  owner,\n  offset = 0,\n  limit = 10,\n  tokenPair,\n}: Params) {\n  const queryParams: LoDcaQueryParams = {\n    owner,\n    statuses: [\"CLOSED\"],\n    offset,\n    limit,\n    tokenPair,\n  };\n  const paramsStr = formatQueryParams(queryParams);\n\n  const response = await fetchClient(`${LO_DCA_API}/limit-orders?${paramsStr}`);\n\n  if (!response.ok) {\n    throw new Error(\"Failed to fetch closed limit orders\");\n  }\n\n  const orders = (await response.json()) as LimitOrder[];\n  return orders;\n}\n","import { DCA_ORDER_MODULE_ID, GLOBAL_CONFIG_ID } from \"./constants\";\nimport {\n  coinWithBalance,\n  Transaction,\n  TransactionObjectArgument,\n} from \"@mysten/sui/transactions\";\n\ninterface PlaceDcaOrderParams {\n  payCoinType: string;\n  targetCoinType: string;\n  payCoinAmountEach: bigint;\n  numOrders: number;\n  interval: number;\n  slippage: bigint;\n  minRate: bigint;\n  maxRate: bigint;\n}\n\nexport async function placeDcaOrder({\n  payCoinType,\n  targetCoinType,\n  payCoinAmountEach,\n  numOrders,\n  interval,\n  slippage,\n  minRate,\n  maxRate,\n}: PlaceDcaOrderParams) {\n  const tx = new Transaction();\n\n  const coinElements: TransactionObjectArgument[] = [];\n  for (let i = 0; i < numOrders; i++) {\n    const coin = coinWithBalance({\n      type: payCoinType,\n      balance: payCoinAmountEach,\n    });\n    coinElements.push(coin);\n  }\n  const vectorCoin = tx.makeMoveVec({\n    elements: coinElements,\n  });\n  tx.moveCall({\n    target: `${DCA_ORDER_MODULE_ID}::place_dca_order`,\n    arguments: [\n      tx.object(GLOBAL_CONFIG_ID),\n      vectorCoin,\n      tx.pure.u64(interval),\n      tx.pure.u64(slippage),\n      tx.pure.u64(minRate),\n      tx.pure.u64(maxRate),\n      tx.object.clock(),\n    ],\n    typeArguments: [payCoinType, targetCoinType],\n  });\n\n  return tx;\n}\n","import { Transaction } from \"@mysten/sui/transactions\";\nimport { DCA_ORDER_MODULE_ID } from \"./constants\";\n\ninterface CancelDcaOrderParams {\n  orderId: string;\n  payCoinType: string;\n  targetCoinType: string;\n}\n\nexport async function cancelDcaOrder({\n  orderId,\n  payCoinType,\n  targetCoinType,\n}: CancelDcaOrderParams) {\n  const tx = new Transaction();\n\n  tx.moveCall({\n    target: `${DCA_ORDER_MODULE_ID}::cancel_dca_order`,\n    arguments: [tx.object(orderId), tx.object.clock()],\n    typeArguments: [payCoinType, targetCoinType],\n  });\n\n  return tx;\n}\n","import { fetchClient } from \"../../config/fetchClient\";\nimport { formatQueryParams } from \"../../libs/url\";\nimport { LO_DCA_API } from \"./constants\";\nimport { DcaOrder, LoDcaQueryParams } from \"./types\";\n\ninterface Params {\n  owner: string;\n  offset: number;\n  limit: number;\n  tokenPair?: string;\n}\n\nexport async function getOpenDcaOrders({\n  owner,\n  offset = 0,\n  limit = 10,\n  tokenPair,\n}: Params) {\n  const queryParams: LoDcaQueryParams = {\n    owner,\n    statuses: [\"ACTIVE\", \"EXPIRED\"],\n    offset,\n    limit,\n    tokenPair,\n  };\n  const paramsStr = formatQueryParams(queryParams);\n\n  const response = await fetchClient(`${LO_DCA_API}/dca-orders?${paramsStr}`);\n\n  if (!response.ok) {\n    throw new Error(\"Failed to fetch open dca orders\");\n  }\n\n  const orders = (await response.json()) as DcaOrder[];\n  return orders;\n}\n","import { fetchClient } from \"../../config/fetchClient\";\nimport { formatQueryParams } from \"../../libs/url\";\nimport { LO_DCA_API } from \"./constants\";\nimport { LoDcaOrderExecution, LoDcaQueryParams } from \"./types\";\n\ninterface Params {\n  owner: string;\n  offset: number;\n  limit: number;\n  tokenPair?: string;\n}\n\nexport async function getClosedDcaOrders({\n  owner,\n  offset = 0,\n  limit = 10,\n  tokenPair,\n}: Params) {\n  const queryParams: LoDcaQueryParams = {\n    owner,\n    statuses: [\"SUCCESS\"],\n    offset,\n    limit,\n    orderType: \"DCA\",\n    tokenPair,\n  };\n  const paramsStr = formatQueryParams(queryParams);\n\n  const response = await fetchClient(\n    `${LO_DCA_API}/order-executions?${paramsStr}`,\n  );\n\n  if (!response.ok) {\n    throw new Error(\"Failed to fetch closed dca orders\");\n  }\n\n  const orders = (await response.json()) as LoDcaOrderExecution[];\n  return orders;\n}\n","import { fetchClient } from \"../../config/fetchClient\";\nimport { formatQueryParams } from \"../../libs/url\";\nimport { LO_DCA_API } from \"./constants\";\nimport { LoDcaOrderExecution, LoDcaQueryParams } from \"./types\";\n\ninterface Params {\n  owner: string;\n  orderId: string;\n  offset: number;\n  limit: number;\n}\n\nexport async function getDcaOrderExecutions({\n  owner,\n  orderId,\n  offset = 0,\n  limit = 10,\n}: Params) {\n  const queryParams: LoDcaQueryParams = {\n    owner,\n    orderId,\n    statuses: [\"SUCCESS\"],\n    offset,\n    limit,\n    orderType: \"DCA\",\n  };\n  const paramsStr = formatQueryParams(queryParams);\n\n  const response = await fetchClient(\n    `${LO_DCA_API}/order-executions?${paramsStr}`,\n  );\n\n  if (!response.ok) {\n    throw new Error(\"Failed to fetch dca order executions\");\n  }\n\n  const orders = (await response.json()) as LoDcaOrderExecution[];\n  return orders;\n}\n","export * from \"./types/metaAg\";\n\nimport { MetaAg } from \"./features/metaAg\";\nimport { getSuiPrice, getTokenPrice, getTokenPrices } from \"./features/prices\";\n\nimport {\n  cancelDcaOrder,\n  cancelLimitOrder,\n  claimExpiredLimitOrder,\n  getClosedDcaOrders,\n  getClosedLimitOrders,\n  getDcaOrderExecutions,\n  getOpenDcaOrders,\n  getOpenLimitOrders,\n  placeDcaOrder,\n  placeLimitOrder,\n} from \"./features/limitDca\";\n\nexport {\n  MetaAg,\n  cancelDcaOrder,\n  cancelLimitOrder,\n  claimExpiredLimitOrder,\n  getClosedDcaOrders,\n  getClosedLimitOrders,\n  getDcaOrderExecutions,\n  getOpenDcaOrders,\n  getOpenLimitOrders,\n  // prices\n  getSuiPrice,\n  getTokenPrice,\n  getTokenPrices,\n  // dca\n  placeDcaOrder,\n  // limit order\n  placeLimitOrder,\n};\n\nexport default {\n  // prices\n  getTokenPrice,\n  getTokenPrices,\n  getSuiPrice,\n\n  // limit order\n  placeLimitOrder,\n  getOpenLimitOrders,\n  cancelLimitOrder,\n  claimExpiredLimitOrder,\n  getClosedLimitOrders,\n\n  // dca\n  placeDcaOrder,\n  getOpenDcaOrders,\n  cancelDcaOrder,\n  getClosedDcaOrders,\n  getDcaOrderExecutions,\n\n  // Meta aggregator\n  MetaAg,\n};\n"],"mappings":"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","names":["getFullnodeUrl","SuiClient","coinWithBalance","Transaction","normalizeStructTag","toBase64","SUI_ADDRESS_ZERO","normalizeSuiAddress","parseStructTag","RESERVED_ADDRESSES","isSystemAddress","address","addr","normalizeSuiAddress","Transaction","normalizeSuiAddress","AsyncCache","id","owned","shared","ids","object","objects","ref","functionName","normalizeSuiAddress","functionEntry","pkg","entry","key","value","_caches","InMemoryObjectCache","__privateAdd","type","__privateGet","cache","_client","_cache","_onEffects","CustomObjectCache","onEffects","client","__privateSet","transactionData","unresolvedObjects","cached","obj","byId","unresolved","input","dedup","res","owner","initialSharedVersion","ownerAddress","_options","next","commands","def","effects","_a","lamportVersion","changedObjects","deletedIds","addedObjects","change","digest","_devInspectCache","SuiClientUtils","client","__privateAdd","params","Transaction","__privateGet","error","__privateSet","CustomObjectCache","getExpectedReturn","returnAmount","slippageBps","commissionBps","tipBps","returnAmountWithDecimal","tipAmountWithDecimal","commissionAmountWithDecimal","expectedReturnWithDecimal","minAmountWithDecimal","coinWithBalance","Transaction","simulateSwapTx","tx","inspector","simulation","res","timeout","MetaAgError","extractAmountOutWrapper","simulateAggregator","provider","quote","options","Transaction","coinOut","coinWithBalance","metaSettle","slippageBps","tipBps","partner","commissionBps","minAmount","expectedAmount","getExpectedReturn","_7K_META_PUBLISHED_AT","_7K_META_VAULT","_7K_META_CONFIG","events","event","_7K_META_PACKAGE_ID","fn","msg","resolve","reject","timer","Commands","Transaction","TransactionDataBuilder","normalizeStructTag","normalizeSuiAddress","toBase64","v4","SUI_TYPE","SUI_FULL_TYPE","API","SWAP_PATH","CHAIN_ID","NORMALIZED_SUI_TYPE","normalizeStructTag","SUI_TYPE","OkxProvider","options","metaOptions","client","amountIn","coinTypeIn","coinTypeOut","signer","isSystemAddress","request","queryString","url","quote","getHeaders","MetaAgError","v4","signTransaction","tx","coin","buildTx","metaSettle","txBytes","bytes","signature","toBase64","generateHmacSha256","message","secretKey","encoder","encodeBase64","binary","i","key","createHmac","method","requestPath","apiKey","apiPassphrase","projectId","timestamp","stringToSign","replaceFinalizeCommand","packageId","builder","TransactionDataBuilder","cmd","normalizeSuiAddress","Commands","Transaction","tx2","simulateOKXSwap","inspector","simulation","res","simulateSwapTx","HERMES_API","DEFAULT_PROVIDERS","MetaAg","options","getFullnodeUrl","SUI_ADDRESS_ZERO","SuiClient","SuiClientUtils","provider","p","providerOptions","MetaAgError","Bluefin7kProvider","catchImportError","FlowxProvider","CetusProvider","OkxProvider","quote","simulation","isAggregatorProvider","simulateAggregator","simulateOKXSwap","error","timeout","expectedAmount","getExpectedReturn","signer","useGasCoin","signTransaction","getTransactionBlockParams","tx","Transaction","coin","coinWithBalance","txBytes","signature","bytes","toBase64","opts","normalizeStructTag","result","_k","v","requests","updated","slippageBps","isSystemAddress","coinOut","metaSettle","isSwapAPIProvider","opt","e","map","fetchClient","input","init","headers","modifiedInit","API_ENDPOINTS","normalizeTokenType","type","SUI_TYPE","SUI_FULL_TYPE","chunkArray","array","chunkSize","chunks","i","MAX_TOTAL_IDS","MAX_IDS_PER_REQUEST","getCurrentTimestamp","getTokenPrice","id","normalizedId","normalizeTokenType","getTokenPrices","ids","limitedIds","idChunks","timestamp","combinedPrices","chunk","requestBody","response","fetchClient","API_ENDPOINTS","acc","priceResponses","priceResponse","getSuiPrice","SUI_FULL_TYPE","coinWithBalance","Transaction","GLOBAL_CONFIG_ID","RATE_SCALE","SLIPPAGE_SCALE","PACKAGE","LIMIT_ORDER_MODULE_ID","DCA_ORDER_MODULE_ID","CONFIG_MODULE_ID","DCA_MAX_RATE","LO_DCA_API","API_ENDPOINTS","placeLimitOrder","accountAddress","payCoinType","targetCoinType","payCoinAmount","rate","slippage","expireTs","devInspect","tx","Transaction","payCoin","coinWithBalance","LIMIT_ORDER_MODULE_ID","GLOBAL_CONFIG_ID","Transaction","cancelLimitOrder","orderId","payCoinType","targetCoinType","tx","Transaction","LIMIT_ORDER_MODULE_ID","Transaction","claimExpiredLimitOrder","orderId","payCoinType","targetCoinType","tx","Transaction","LIMIT_ORDER_MODULE_ID","formatQueryParams","params","str","key","value","v","getOpenLimitOrders","owner","offset","limit","tokenPair","paramsStr","formatQueryParams","response","fetchClient","LO_DCA_API","getClosedLimitOrders","owner","offset","limit","tokenPair","paramsStr","formatQueryParams","response","fetchClient","LO_DCA_API","coinWithBalance","Transaction","placeDcaOrder","payCoinType","targetCoinType","payCoinAmountEach","numOrders","interval","slippage","minRate","maxRate","tx","coinElements","i","coin","vectorCoin","DCA_ORDER_MODULE_ID","GLOBAL_CONFIG_ID","Transaction","cancelDcaOrder","orderId","payCoinType","targetCoinType","tx","Transaction","DCA_ORDER_MODULE_ID","getOpenDcaOrders","owner","offset","limit","tokenPair","paramsStr","formatQueryParams","response","fetchClient","LO_DCA_API","getClosedDcaOrders","owner","offset","limit","tokenPair","paramsStr","formatQueryParams","response","fetchClient","LO_DCA_API","getDcaOrderExecutions","owner","orderId","offset","limit","paramsStr","formatQueryParams","response","fetchClient","LO_DCA_API","index_default","getTokenPrice","getTokenPrices","getSuiPrice","placeLimitOrder","getOpenLimitOrders","cancelLimitOrder","claimExpiredLimitOrder","getClosedLimitOrders","placeDcaOrder","getOpenDcaOrders","cancelDcaOrder","getClosedDcaOrders","getDcaOrderExecutions","MetaAg"]}

package/package.json

@@ -1,44 +1,35 @@
 {
   "name": "@7kprotocol/sdk-ts",
-  "version": "3.6.1-beta.0",
+  "version": "3.6.1-beta.2",
   "description": "",
   "exports": {
     ".": {
       "import": {
-        "types": "./lib/esm/types/index.d.ts",
-        "default": "./lib/esm/index.mjs"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
       },
       "require": {
-        "types": "./lib/cjs/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       }
-    },
-    "./esm": {
-      "types": "./lib/esm/types/index.d.ts",
-      "default": "./lib/esm/index.mjs"
-    },
-    "./cjs": {
-      "types": "./lib/cjs/types/index.d.ts",
-      "default": "./lib/cjs/index.js"
     }
   },
-  "types": "./lib/cjs/types/index.d.ts",
-  "main": "./lib/cjs/index.js",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
   "files": [
-    "lib/**/*"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "clean": "rm -rf ./lib",
+    "clean": "rm -rf ./dist",
     "prepare": "husky",
     "tsc": "npx tsc -p ./configs/tsconfig.base.json --noEmit",
     "lint": "npx eslint ./src",
     "prettier": "npx prettier --write .",
-    "build": "npm run clean && npm run build:esm && npm run build:cjs",
-    "build:esm": "tsc -p ./configs/tsconfig.esm.json && mv lib/esm/index.js lib/esm/index.mjs",
-    "build:cjs": "tsc -p ./configs/tsconfig.cjs.json",
+    "build": "tsup",
+    "watch": "tsup --watch",
     "prepack": "npm run build",
     "test": "mocha --timeout 60000",
     "pack:local": "npm run build && npm pack",
@@ -68,6 +59,7 @@
     "husky": "^9.1.7",
     "mocha": "^11.6.0",
     "ts-node": "^10.9.2",
+    "tsup": "^8.3.5",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.34.1"
   },

package/lib/cjs/config/fetchClient.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchClient = fetchClient;
-async function fetchClient(input, init) {
-    const headers = new Headers(init?.headers);
-    // intercept the request and add the headers go here...
-    const modifiedInit = {
-        ...init,
-        headers,
-    };
-    return fetch(input, modifiedInit);
-}

package/lib/cjs/constants/_7k.js

@@ -1,20 +0,0 @@
-"use strict";
-// export const _7K_PACKAGE_ID =
-//   "0x62412b7268c35f3808336aee57a52836501f40b8ba5d936f8ad275e672befd04";
-// //legacy V4: "0xe8f996ea6ff38c557c253d3b93cfe2ebf393816487266786371aa4532a9229f2";
-// //legacy V3: "0x7ea6e27ad7af6f3b8671d59df1aaebd7c03dddab893e52a714227b2f4fe91519";
-// //legacy V2: "0xa13447019cd982d6bef91cf7b46ad384a52583b1dfc2bdecf31ef0c4bd787a0f";
-// //legacy V1: "0xd48e7cdc9e92bec69ce3baa75578010458a0c5b2733d661a84971e8cef6806bc";
-// export const _7K_CONFIG =
-//   "0x47442a93f7727d188ba7cb71031170d1786af70013cb7ad5115f3fe877ff0c54";
-// //legacy v3: "0x0f8fc23dbcc9362b72c7a4c5aa53fcefa02ebfbb83a812c8c262ccd2c076d9ee";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._7K_PARTNER_ADDRESS = exports._7K_META_CONFIG = exports._7K_META_VAULT = exports._7K_META_PACKAGE_ID = exports._7K_META_PUBLISHED_AT = void 0;
-// export const _7K_VAULT =
-//   "0x442ad50389ed5cda6f7a6f5a7ae6361a4c05ef1d9fb2e54fbba5a268d690bfe6";
-// //legacy v3: "0x39a3c55742c0e011b6f65548e73cf589e1ae5e82dbfab449ca57f24c3bcd9514";
-exports._7K_META_PUBLISHED_AT = "0x17c0b1f7a6ad73f51268f16b8c06c049eecc2f28a270cdd29c06e3d2dea23302";
-exports._7K_META_PACKAGE_ID = "0x17c0b1f7a6ad73f51268f16b8c06c049eecc2f28a270cdd29c06e3d2dea23302";
-exports._7K_META_VAULT = "0x9a8abd32fe5721307ce3b697cf982ee84e9ffbd58d667a4a199f1683c1a3d23c";
-exports._7K_META_CONFIG = "0xbbb3a51877ed9b492f26f4e2181811cfb2bd70c532f6f7621263d122d5e96b56";
-exports._7K_PARTNER_ADDRESS = "0x93ead46c1e48a9b62e25b6787f2ea6f75caedabb21726f12431acc4381f5f4c5";

package/lib/cjs/constants/apiEndpoints.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_ENDPOINTS = void 0;
-exports.API_ENDPOINTS = {
-    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",
-};

package/lib/cjs/constants/sui.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUI_ADDRESS_ZERO = void 0;
-exports.SUI_ADDRESS_ZERO = "0x0000000000000000000000000000000000000000000000000000000000000000";

package/lib/cjs/constants/tokens.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NATIVE_USDC_TOKEN_TYPE = exports.USDC_TOKEN_TYPE = exports.SUI_FULL_TYPE = exports.SUI_TYPE = void 0;
-exports.SUI_TYPE = "0x2::sui::SUI";
-exports.SUI_FULL_TYPE = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
-exports.USDC_TOKEN_TYPE = "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN";
-exports.NATIVE_USDC_TOKEN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";

package/lib/cjs/features/limitDca/cancelDcaOrder.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cancelDcaOrder = cancelDcaOrder;
-const transactions_1 = require("@mysten/sui/transactions");
-const constants_1 = require("./constants");
-async function cancelDcaOrder({ orderId, payCoinType, targetCoinType, }) {
-    const tx = new transactions_1.Transaction();
-    tx.moveCall({
-        target: `${constants_1.DCA_ORDER_MODULE_ID}::cancel_dca_order`,
-        arguments: [tx.object(orderId), tx.object.clock()],
-        typeArguments: [payCoinType, targetCoinType],
-    });
-    return tx;
-}

package/lib/cjs/features/limitDca/cancelLimitOrder.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cancelLimitOrder = cancelLimitOrder;
-const transactions_1 = require("@mysten/sui/transactions");
-const constants_1 = require("./constants");
-async function cancelLimitOrder({ orderId, payCoinType, targetCoinType, }) {
-    const tx = new transactions_1.Transaction();
-    tx.moveCall({
-        target: `${constants_1.LIMIT_ORDER_MODULE_ID}::cancel_limit_order`,
-        typeArguments: [payCoinType, targetCoinType],
-        arguments: [tx.object(orderId), tx.object.clock()],
-    });
-    return tx;
-}

package/lib/cjs/features/limitDca/claimExpiredLimitOrder.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.claimExpiredLimitOrder = claimExpiredLimitOrder;
-const transactions_1 = require("@mysten/sui/transactions");
-const constants_1 = require("./constants");
-async function claimExpiredLimitOrder({ orderId, payCoinType, targetCoinType, }) {
-    const tx = new transactions_1.Transaction();
-    tx.moveCall({
-        target: `${constants_1.LIMIT_ORDER_MODULE_ID}::claim_expired_order`,
-        typeArguments: [payCoinType, targetCoinType],
-        arguments: [tx.object(orderId), tx.object.clock()],
-    });
-    return tx;
-}

package/lib/cjs/features/limitDca/constants.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LO_DCA_API = exports.DCA_MAX_RATE = exports.CONFIG_MODULE_ID = exports.DCA_ORDER_MODULE_ID = exports.LIMIT_ORDER_MODULE_ID = exports.PACKAGE = exports.SLIPPAGE_SCALE = exports.RATE_SCALE = exports.GLOBAL_CONFIG_ID = void 0;
-const apiEndpoints_1 = require("../../constants/apiEndpoints");
-exports.GLOBAL_CONFIG_ID = "0xffc7f420b481ed7a012b42e125fd7e5716b5673759cf4629e5fcfebce970a72d";
-exports.RATE_SCALE = BigInt("1000000000000");
-exports.SLIPPAGE_SCALE = BigInt("10000");
-exports.PACKAGE = "0x0ef0f805710cf53c10f29c4f73e1144a662747e1839689a846e2520cae122adc";
-exports.LIMIT_ORDER_MODULE_ID = `${exports.PACKAGE}::limit_order`;
-exports.DCA_ORDER_MODULE_ID = `${exports.PACKAGE}::dca_order`;
-exports.CONFIG_MODULE_ID = `${exports.PACKAGE}::config`;
-exports.DCA_MAX_RATE = BigInt("18446744073709551615");
-exports.LO_DCA_API = `${apiEndpoints_1.API_ENDPOINTS.LO_DCA}/api`;

package/lib/cjs/features/limitDca/getClosedDcaOrders.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClosedDcaOrders = getClosedDcaOrders;
-const fetchClient_1 = require("../../config/fetchClient");
-const url_1 = require("../../libs/url");
-const constants_1 = require("./constants");
-async function getClosedDcaOrders({ owner, offset = 0, limit = 10, tokenPair, }) {
-    const queryParams = {
-        owner,
-        statuses: ["SUCCESS"],
-        offset,
-        limit,
-        orderType: "DCA",
-        tokenPair,
-    };
-    const paramsStr = (0, url_1.formatQueryParams)(queryParams);
-    const response = await (0, fetchClient_1.fetchClient)(`${constants_1.LO_DCA_API}/order-executions?${paramsStr}`);
-    if (!response.ok) {
-        throw new Error("Failed to fetch closed dca orders");
-    }
-    const orders = (await response.json());
-    return orders;
-}

package/lib/cjs/features/limitDca/getClosedLimitOrders.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClosedLimitOrders = getClosedLimitOrders;
-const fetchClient_1 = require("../../config/fetchClient");
-const url_1 = require("../../libs/url");
-const constants_1 = require("./constants");
-async function getClosedLimitOrders({ owner, offset = 0, limit = 10, tokenPair, }) {
-    const queryParams = {
-        owner,
-        statuses: ["CLOSED"],
-        offset,
-        limit,
-        tokenPair,
-    };
-    const paramsStr = (0, url_1.formatQueryParams)(queryParams);
-    const response = await (0, fetchClient_1.fetchClient)(`${constants_1.LO_DCA_API}/limit-orders?${paramsStr}`);
-    if (!response.ok) {
-        throw new Error("Failed to fetch closed limit orders");
-    }
-    const orders = (await response.json());
-    return orders;
-}

package/lib/cjs/features/limitDca/getDcaOrderExecutions.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDcaOrderExecutions = getDcaOrderExecutions;
-const fetchClient_1 = require("../../config/fetchClient");
-const url_1 = require("../../libs/url");
-const constants_1 = require("./constants");
-async function getDcaOrderExecutions({ owner, orderId, offset = 0, limit = 10, }) {
-    const queryParams = {
-        owner,
-        orderId,
-        statuses: ["SUCCESS"],
-        offset,
-        limit,
-        orderType: "DCA",
-    };
-    const paramsStr = (0, url_1.formatQueryParams)(queryParams);
-    const response = await (0, fetchClient_1.fetchClient)(`${constants_1.LO_DCA_API}/order-executions?${paramsStr}`);
-    if (!response.ok) {
-        throw new Error("Failed to fetch dca order executions");
-    }
-    const orders = (await response.json());
-    return orders;
-}

package/lib/cjs/features/limitDca/getOpenDcaOrders.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOpenDcaOrders = getOpenDcaOrders;
-const fetchClient_1 = require("../../config/fetchClient");
-const url_1 = require("../../libs/url");
-const constants_1 = require("./constants");
-async function getOpenDcaOrders({ owner, offset = 0, limit = 10, tokenPair, }) {
-    const queryParams = {
-        owner,
-        statuses: ["ACTIVE", "EXPIRED"],
-        offset,
-        limit,
-        tokenPair,
-    };
-    const paramsStr = (0, url_1.formatQueryParams)(queryParams);
-    const response = await (0, fetchClient_1.fetchClient)(`${constants_1.LO_DCA_API}/dca-orders?${paramsStr}`);
-    if (!response.ok) {
-        throw new Error("Failed to fetch open dca orders");
-    }
-    const orders = (await response.json());
-    return orders;
-}

package/lib/cjs/features/limitDca/getOpenLimitOrders.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOpenLimitOrders = getOpenLimitOrders;
-const fetchClient_1 = require("../../config/fetchClient");
-const url_1 = require("../../libs/url");
-const constants_1 = require("./constants");
-async function getOpenLimitOrders({ owner, offset = 0, limit = 10, tokenPair, }) {
-    const queryParams = {
-        owner,
-        statuses: ["ACTIVE", "EXPIRED"],
-        offset,
-        limit,
-        tokenPair,
-    };
-    const paramsStr = (0, url_1.formatQueryParams)(queryParams);
-    const response = await (0, fetchClient_1.fetchClient)(`${constants_1.LO_DCA_API}/limit-orders?${paramsStr}`);
-    if (!response.ok) {
-        throw new Error("Failed to fetch open limit orders");
-    }
-    const orders = (await response.json());
-    return orders;
-}