@gardenfi/swap 0.1.0 → 0.1.2

package/dist/index121.js

@@ -1,39 +1,576 @@
-import { encodeEventTopics as b } from "./index212.js";
-import { numberToHex as m } from "./index81.js";
-import { createFilterRequestScope as h } from "./index299.js";
-async function l(r, { address: p, args: a, event: e, events: c, fromBlock: n, strict: f, toBlock: i } = {}) {
-  const o = c ?? (e ? [e] : void 0), u = h(r, {
-    method: "eth_newFilter"
-  });
-  let t = [];
-  o && (t = [o.flatMap((d) => b({
-    abi: [d],
-    eventName: d.name,
-    args: a
-  }))], e && (t = t[0]));
-  const s = await r.request({
-    method: "eth_newFilter",
-    params: [
-      {
-        address: p,
-        fromBlock: typeof n == "bigint" ? m(n) : n,
-        toBlock: typeof i == "bigint" ? m(i) : i,
-        ...t.length ? { topics: t } : {}
+import { fromBase64 as m } from "./index114.js";
+import { chunk as x } from "./index318.js";
+import { bcs as p } from "./index320.js";
+import { Transaction as C } from "./index77.js";
+import { jsonRpcClientResolveTransactionPlugin as I } from "./index321.js";
+import { TransactionDataBuilder as P } from "./index314.js";
+import { normalizeSuiAddress as k } from "./index117.js";
+import { Experimental_CoreClient as E } from "./index322.js";
+import { ObjectError as y } from "./index323.js";
+import { parseTransactionBcs as N, parseTransactionEffectsBcs as A } from "./index324.js";
+var h = (t) => {
+  throw TypeError(t);
+}, S = (t, e, r) => e.has(t) || h("Cannot " + r), i = (t, e, r) => (S(t, e, "read from private field"), r ? r.call(t) : e.get(t)), $ = (t, e, r) => e.has(t) ? h("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, r), B = (t, e, r, n) => (S(t, e, "write to private field"), e.set(t, r), r), a;
+class Q extends E {
+  constructor({
+    jsonRpcClient: e,
+    mvr: r
+  }) {
+    super({ network: e.network, base: e, mvr: r }), $(this, a), B(this, a, e);
+  }
+  async getObjects(e) {
+    const r = x(e.objectIds, 50), n = [];
+    for (const d of r) {
+      const o = await i(this, a).multiGetObjects({
+        ids: d,
+        options: {
+          showOwner: !0,
+          showType: !0,
+          showBcs: !0,
+          showPreviousTransaction: !0
+        },
+        signal: e.signal
+      });
+      for (const [u, s] of o.entries())
+        s.error ? n.push(y.fromResponse(s.error, d[u])) : n.push(v(s.data));
+    }
+    return {
+      objects: n
+    };
+  }
+  async getOwnedObjects(e) {
+    const r = await i(this, a).getOwnedObjects({
+      owner: e.address,
+      limit: e.limit,
+      cursor: e.cursor,
+      options: {
+        showOwner: !0,
+        showType: !0,
+        showBcs: !0,
+        showPreviousTransaction: !0
+      },
+      filter: e.type ? { StructType: e.type } : null,
+      signal: e.signal
+    });
+    return {
+      objects: r.data.map((n) => {
+        if (n.error)
+          throw y.fromResponse(n.error);
+        return v(n.data);
+      }),
+      hasNextPage: r.hasNextPage,
+      cursor: r.nextCursor ?? null
+    };
+  }
+  async getCoins(e) {
+    const r = await i(this, a).getCoins({
+      owner: e.address,
+      coinType: e.coinType,
+      limit: e.limit,
+      cursor: e.cursor,
+      signal: e.signal
+    });
+    return {
+      objects: r.data.map((n) => ({
+        id: n.coinObjectId,
+        version: n.version,
+        digest: n.digest,
+        balance: n.balance,
+        type: `0x2::coin::Coin<${n.coinType}>`,
+        content: Promise.resolve(
+          _.serialize({
+            id: n.coinObjectId,
+            balance: {
+              value: n.balance
+            }
+          }).toBytes()
+        ),
+        owner: {
+          $kind: "ObjectOwner",
+          ObjectOwner: e.address
+        },
+        previousTransaction: n.previousTransaction
+      })),
+      hasNextPage: r.hasNextPage,
+      cursor: r.nextCursor ?? null
+    };
+  }
+  async getBalance(e) {
+    const r = await i(this, a).getBalance({
+      owner: e.address,
+      coinType: e.coinType,
+      signal: e.signal
+    });
+    return {
+      balance: {
+        coinType: r.coinType,
+        balance: r.totalBalance
+      }
+    };
+  }
+  async getAllBalances(e) {
+    return {
+      balances: (await i(this, a).getAllBalances({
+        owner: e.address,
+        signal: e.signal
+      })).map((n) => ({
+        coinType: n.coinType,
+        balance: n.totalBalance
+      })),
+      hasNextPage: !1,
+      cursor: null
+    };
+  }
+  async getTransaction(e) {
+    const r = await i(this, a).getTransactionBlock({
+      digest: e.digest,
+      options: {
+        showRawInput: !0,
+        showObjectChanges: !0,
+        showRawEffects: !0,
+        showEvents: !0,
+        showEffects: !0,
+        showBalanceChanges: !0
+      },
+      signal: e.signal
+    });
+    return {
+      transaction: T(r)
+    };
+  }
+  async executeTransaction(e) {
+    const r = await i(this, a).executeTransactionBlock({
+      transactionBlock: e.transaction,
+      signature: e.signatures,
+      options: {
+        showRawEffects: !0,
+        showEvents: !0,
+        showObjectChanges: !0,
+        showRawInput: !0,
+        showEffects: !0,
+        showBalanceChanges: !0
+      },
+      signal: e.signal
+    });
+    return {
+      transaction: T(r)
+    };
+  }
+  async dryRunTransaction(e) {
+    const r = C.from(e.transaction), n = await i(this, a).dryRunTransactionBlock({
+      transactionBlock: e.transaction,
+      signal: e.signal
+    }), { effects: d, objectTypes: o } = V({
+      effects: n.effects,
+      objectChanges: n.objectChanges
+    });
+    return {
+      transaction: {
+        digest: await r.getDigest(),
+        epoch: null,
+        effects: d,
+        objectTypes: Promise.resolve(o),
+        signatures: [],
+        transaction: N(e.transaction),
+        balanceChanges: n.balanceChanges.map((u) => ({
+          coinType: u.coinType,
+          address: D(u.owner),
+          amount: u.amount
+        }))
+      }
+    };
+  }
+  async getReferenceGasPrice(e) {
+    const r = await i(this, a).getReferenceGasPrice({
+      signal: e == null ? void 0 : e.signal
+    });
+    return {
+      referenceGasPrice: String(r)
+    };
+  }
+  async getDynamicFields(e) {
+    const r = await i(this, a).getDynamicFields({
+      parentId: e.parentId,
+      limit: e.limit,
+      cursor: e.cursor
+    });
+    return {
+      dynamicFields: r.data.map((n) => ({
+        id: n.objectId,
+        type: n.objectType,
+        name: {
+          type: n.name.type,
+          bcs: m(n.bcsName)
+        }
+      })),
+      hasNextPage: r.hasNextPage,
+      cursor: r.nextCursor
+    };
+  }
+  async verifyZkLoginSignature(e) {
+    const r = await i(this, a).verifyZkLoginSignature({
+      bytes: e.bytes,
+      signature: e.signature,
+      intentScope: e.intentScope,
+      author: e.author
+    });
+    return {
+      success: r.success,
+      errors: r.errors
+    };
+  }
+  async defaultNameServiceName(e) {
+    return {
+      data: {
+        name: (await i(this, a).resolveNameServiceNames(e)).data[0]
+      }
+    };
+  }
+  resolveTransactionPlugin() {
+    return I(i(this, a));
+  }
+  async getMoveFunction(e) {
+    const r = await i(this, a).getNormalizedMoveFunction({
+      package: (await this.mvr.resolvePackage({ package: e.packageId })).package,
+      module: e.moduleName,
+      function: e.name
+    });
+    return {
+      function: {
+        packageId: k(e.packageId),
+        moduleName: e.moduleName,
+        name: e.name,
+        visibility: M(r.visibility),
+        isEntry: r.isEntry,
+        typeParameters: r.typeParameters.map((n) => ({
+          isPhantom: !1,
+          constraints: U(n)
+        })),
+        parameters: r.parameters.map((n) => j(n)),
+        returns: r.return.map((n) => j(n))
+      }
+    };
+  }
+}
+a = /* @__PURE__ */ new WeakMap();
+function v(t) {
+  var e;
+  return {
+    id: t.objectId,
+    version: t.version,
+    digest: t.digest,
+    type: t.type,
+    content: Promise.resolve(
+      ((e = t.bcs) == null ? void 0 : e.dataType) === "moveObject" ? m(t.bcs.bcsBytes) : new Uint8Array()
+    ),
+    owner: l(t.owner),
+    previousTransaction: t.previousTransaction ?? null
+  };
+}
+function l(t) {
+  if (t === "Immutable")
+    return {
+      $kind: "Immutable",
+      Immutable: !0
+    };
+  if ("ConsensusAddressOwner" in t)
+    return {
+      $kind: "ConsensusAddressOwner",
+      ConsensusAddressOwner: {
+        owner: t.ConsensusAddressOwner.owner,
+        startVersion: t.ConsensusAddressOwner.start_version
       }
-    ]
+    };
+  if ("AddressOwner" in t)
+    return {
+      $kind: "AddressOwner",
+      AddressOwner: t.AddressOwner
+    };
+  if ("ObjectOwner" in t)
+    return {
+      $kind: "ObjectOwner",
+      ObjectOwner: t.ObjectOwner
+    };
+  if ("Shared" in t)
+    return {
+      $kind: "Shared",
+      Shared: {
+        initialSharedVersion: t.Shared.initial_shared_version
+      }
+    };
+  throw new Error(`Unknown owner type: ${JSON.stringify(t)}`);
+}
+function D(t) {
+  if (t === "Immutable")
+    return null;
+  if ("ConsensusAddressOwner" in t)
+    return t.ConsensusAddressOwner.owner;
+  if ("AddressOwner" in t)
+    return t.AddressOwner;
+  if ("ObjectOwner" in t)
+    return t.ObjectOwner;
+  if ("Shared" in t)
+    return null;
+  throw new Error(`Unknown owner type: ${JSON.stringify(t)}`);
+}
+function T(t) {
+  var o, u, s;
+  const e = p.SenderSignedData.parse(m(t.rawTransaction))[0], r = {};
+  (o = t.objectChanges) == null || o.forEach((c) => {
+    c.type !== "published" && (r[c.objectId] = c.objectType);
   });
+  const n = p.TransactionData.serialize(e.intentMessage.value).toBytes(), d = P.restore({
+    version: 2,
+    sender: e.intentMessage.value.V1.sender,
+    expiration: e.intentMessage.value.V1.expiration,
+    gasData: e.intentMessage.value.V1.gasData,
+    inputs: e.intentMessage.value.V1.kind.ProgrammableTransaction.inputs,
+    commands: e.intentMessage.value.V1.kind.ProgrammableTransaction.commands
+  });
+  return {
+    digest: t.digest,
+    epoch: ((u = t.effects) == null ? void 0 : u.executedEpoch) ?? null,
+    effects: A(new Uint8Array(t.rawEffects)),
+    objectTypes: Promise.resolve(r),
+    transaction: {
+      ...d,
+      bcs: n
+    },
+    signatures: e.txSignatures,
+    balanceChanges: ((s = t.balanceChanges) == null ? void 0 : s.map((c) => ({
+      coinType: c.coinType,
+      address: D(c.owner),
+      amount: c.amount
+    }))) ?? []
+  };
+}
+function V({
+  bytes: t,
+  effects: e,
+  objectChanges: r
+}) {
+  var u;
+  const n = [], d = [], o = {};
+  return r == null || r.forEach((s) => {
+    var c, g, O, f;
+    switch (s.type) {
+      case "published":
+        n.push({
+          id: s.packageId,
+          inputState: "DoesNotExist",
+          inputVersion: null,
+          inputDigest: null,
+          inputOwner: null,
+          outputState: "PackageWrite",
+          outputVersion: s.version,
+          outputDigest: s.digest,
+          outputOwner: null,
+          idOperation: "Created"
+        });
+        break;
+      case "transferred":
+        n.push({
+          id: s.objectId,
+          inputState: "Exists",
+          inputVersion: s.version,
+          inputDigest: s.digest,
+          inputOwner: {
+            $kind: "AddressOwner",
+            AddressOwner: s.sender
+          },
+          outputState: "ObjectWrite",
+          outputVersion: s.version,
+          outputDigest: s.digest,
+          outputOwner: l(s.recipient),
+          idOperation: "None"
+        }), o[s.objectId] = s.objectType;
+        break;
+      case "mutated":
+        n.push({
+          id: s.objectId,
+          inputState: "Exists",
+          inputVersion: s.previousVersion,
+          inputDigest: null,
+          inputOwner: l(s.owner),
+          outputState: "ObjectWrite",
+          outputVersion: s.version,
+          outputDigest: s.digest,
+          outputOwner: l(s.owner),
+          idOperation: "None"
+        }), o[s.objectId] = s.objectType;
+        break;
+      case "deleted":
+        n.push({
+          id: s.objectId,
+          inputState: "Exists",
+          inputVersion: s.version,
+          inputDigest: ((g = (c = e.deleted) == null ? void 0 : c.find((b) => b.objectId === s.objectId)) == null ? void 0 : g.digest) ?? null,
+          inputOwner: null,
+          outputState: "DoesNotExist",
+          outputVersion: null,
+          outputDigest: null,
+          outputOwner: null,
+          idOperation: "Deleted"
+        }), o[s.objectId] = s.objectType;
+        break;
+      case "wrapped":
+        n.push({
+          id: s.objectId,
+          inputState: "Exists",
+          inputVersion: s.version,
+          inputDigest: null,
+          inputOwner: {
+            $kind: "AddressOwner",
+            AddressOwner: s.sender
+          },
+          outputState: "ObjectWrite",
+          outputVersion: s.version,
+          outputDigest: ((f = (O = e.wrapped) == null ? void 0 : O.find((b) => b.objectId === s.objectId)) == null ? void 0 : f.digest) ?? null,
+          outputOwner: {
+            $kind: "ObjectOwner",
+            ObjectOwner: s.sender
+          },
+          idOperation: "None"
+        }), o[s.objectId] = s.objectType;
+        break;
+      case "created":
+        n.push({
+          id: s.objectId,
+          inputState: "DoesNotExist",
+          inputVersion: null,
+          inputDigest: null,
+          inputOwner: null,
+          outputState: "ObjectWrite",
+          outputVersion: s.version,
+          outputDigest: s.digest,
+          outputOwner: l(s.owner),
+          idOperation: "Created"
+        }), o[s.objectId] = s.objectType;
+        break;
+    }
+  }), {
+    objectTypes: o,
+    effects: {
+      bcs: t ?? null,
+      digest: e.transactionDigest,
+      version: 2,
+      status: e.status.status === "success" ? { success: !0, error: null } : { success: !1, error: e.status.error },
+      gasUsed: e.gasUsed,
+      transactionDigest: e.transactionDigest,
+      gasObject: {
+        id: (u = e.gasObject) == null ? void 0 : u.reference.objectId,
+        inputState: "Exists",
+        inputVersion: null,
+        inputDigest: null,
+        inputOwner: null,
+        outputState: "ObjectWrite",
+        outputVersion: e.gasObject.reference.version,
+        outputDigest: e.gasObject.reference.digest,
+        outputOwner: l(e.gasObject.owner),
+        idOperation: "None"
+      },
+      eventsDigest: e.eventsDigest ?? null,
+      dependencies: e.dependencies ?? [],
+      lamportVersion: e.gasObject.reference.version,
+      changedObjects: n,
+      unchangedConsensusObjects: d,
+      auxiliaryDataDigest: null
+    }
+  };
+}
+const R = p.struct("Balance", {
+  value: p.u64()
+}), _ = p.struct("Coin", {
+  id: p.Address,
+  balance: R
+});
+function j(t) {
+  if (typeof t != "string") {
+    if ("Reference" in t)
+      return {
+        reference: "immutable",
+        body: w(t.Reference)
+      };
+    if ("MutableReference" in t)
+      return {
+        reference: "mutable",
+        body: w(t.MutableReference)
+      };
+  }
   return {
-    abi: o,
-    args: a,
-    eventName: e ? e.name : void 0,
-    fromBlock: n,
-    id: s,
-    request: u(s),
-    strict: !!f,
-    toBlock: i,
-    type: "event"
+    reference: null,
+    body: w(t)
   };
 }
+function w(t) {
+  switch (t) {
+    case "Address":
+      return { $kind: "address" };
+    case "Bool":
+      return { $kind: "bool" };
+    case "U8":
+      return { $kind: "u8" };
+    case "U16":
+      return { $kind: "u16" };
+    case "U32":
+      return { $kind: "u32" };
+    case "U64":
+      return { $kind: "u64" };
+    case "U128":
+      return { $kind: "u128" };
+    case "U256":
+      return { $kind: "u256" };
+  }
+  if (typeof t == "string")
+    throw new Error(`Unknown type: ${t}`);
+  if ("Vector" in t)
+    return {
+      $kind: "vector",
+      vector: w(t.Vector)
+    };
+  if ("Struct" in t)
+    return {
+      $kind: "datatype",
+      datatype: {
+        typeName: `${k(t.Struct.address)}::${t.Struct.module}::${t.Struct.name}`,
+        typeParameters: t.Struct.typeArguments.map((e) => w(e))
+      }
+    };
+  if ("TypeParameter" in t)
+    return {
+      $kind: "typeParameter",
+      index: t.TypeParameter
+    };
+  throw new Error(`Unknown type: ${JSON.stringify(t)}`);
+}
+function U(t) {
+  return t.abilities.map((e) => {
+    switch (e) {
+      case "Copy":
+        return "copy";
+      case "Drop":
+        return "drop";
+      case "Store":
+        return "store";
+      case "Key":
+        return "key";
+      default:
+        return "unknown";
+    }
+  });
+}
+function M(t) {
+  switch (t) {
+    case "Public":
+      return "public";
+    case "Private":
+      return "private";
+    case "Friend":
+      return "friend";
+    default:
+      return "unknown";
+  }
+}
 export {
-  l as createEventFilter
+  Q as JSONRpcCoreClient
 };

package/dist/index122.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./index299.cjs");async function i(e){const n=r.createFilterRequestScope(e,{method:"eth_newPendingTransactionFilter"}),t=await e.request({method:"eth_newPendingTransactionFilter"});return{id:t,request:n(t),type:"transaction"}}exports.createPendingTransactionFilter=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./index123.cjs"),j=require("./index124.cjs");function q(n){const{batch:a,chain:e,ccipRead:d,key:b="base",name:f="Base Client",type:g="base"}=n,o=n.experimental_blockTag??(typeof(e==null?void 0:e.experimental_preconfirmationTime)=="number"?"pending":void 0),m=(e==null?void 0:e.blockTime)??12e3,p=Math.min(Math.max(Math.floor(m/2),500),4e3),t=n.pollingInterval??p,x=n.cacheTime??t,i=n.account?h.parseAccount(n.account):void 0,{config:T,request:k,value:y}=n.transport({account:i,chain:e,pollingInterval:t}),v={...T,...y},c={account:i,batch:a,cacheTime:x,ccipRead:d,chain:e,key:b,name:f,pollingInterval:t,request:k,transport:v,type:g,uid:j.uid(),...o?{experimental_blockTag:o}:{}};function l(u){return _=>{const r=_(u);for(const M in c)delete r[M];const s={...u,...r};return Object.assign(s,{extend:l(s)})}}return Object.assign(c,{extend:l(c)})}exports.createClient=q;

package/dist/index122.js

@@ -1,12 +1,36 @@
-import { createFilterRequestScope as r } from "./index299.js";
-async function a(e) {
-  const n = r(e, {
-    method: "eth_newPendingTransactionFilter"
-  }), t = await e.request({
-    method: "eth_newPendingTransactionFilter"
-  });
-  return { id: t, request: n(t), type: "transaction" };
+import { parseAccount as I } from "./index123.js";
+import { uid as M } from "./index124.js";
+function O(e) {
+  const { batch: a, chain: n, ccipRead: d, key: f = "base", name: m = "Base Client", type: b = "base" } = e, c = e.experimental_blockTag ?? (typeof (n == null ? void 0 : n.experimental_preconfirmationTime) == "number" ? "pending" : void 0), p = (n == null ? void 0 : n.blockTime) ?? 12e3, g = Math.min(Math.max(Math.floor(p / 2), 500), 4e3), t = e.pollingInterval ?? g, x = e.cacheTime ?? t, i = e.account ? I(e.account) : void 0, { config: T, request: k, value: _ } = e.transport({
+    account: i,
+    chain: n,
+    pollingInterval: t
+  }), v = { ...T, ..._ }, o = {
+    account: i,
+    batch: a,
+    cacheTime: x,
+    ccipRead: d,
+    chain: n,
+    key: f,
+    name: m,
+    pollingInterval: t,
+    request: k,
+    transport: v,
+    type: b,
+    uid: M(),
+    ...c ? { experimental_blockTag: c } : {}
+  };
+  function l(r) {
+    return (y) => {
+      const s = y(r);
+      for (const h in o)
+        delete s[h];
+      const u = { ...r, ...s };
+      return Object.assign(u, { extend: l(u) });
+    };
+  }
+  return Object.assign(o, { extend: l(o) });
 }
 export {
-  a as createPendingTransactionFilter
+  O as createClient
 };

package/dist/index123.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const g=require("./index110.cjs"),m=require("./index96.cjs"),f=require("./index233.cjs"),q=require("./index101.cjs"),G=require("./index125.cjs");async function C(i,u){const{abi:a,address:r,args:c,functionName:n,dataSuffix:o,...t}=u,d=m.encodeFunctionData({abi:a,args:c,functionName:n});try{return await q.getAction(i,G.estimateGas,"estimateGas")({data:`${d}${o?o.replace("0x",""):""}`,to:r,...t})}catch(s){const e=t.account?g.parseAccount(t.account):void 0;throw f.getContractError(s,{abi:a,address:r,args:c,docsPath:"/docs/contract/estimateContractGas",functionName:n,sender:e==null?void 0:e.address})}}exports.estimateContractGas=C;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function r(e){return typeof e=="string"?{address:e,type:"json-rpc"}:e}exports.parseAccount=r;

package/dist/index123.js

@@ -1,32 +1,6 @@
-import { parseAccount as f } from "./index110.js";
-import { encodeFunctionData as u } from "./index96.js";
-import { getContractError as p } from "./index233.js";
-import { getAction as g } from "./index101.js";
-import { estimateGas as G } from "./index125.js";
-async function A(i, m) {
-  const { abi: o, address: r, args: e, functionName: s, dataSuffix: c, ...t } = m, d = u({
-    abi: o,
-    args: e,
-    functionName: s
-  });
-  try {
-    return await g(i, G, "estimateGas")({
-      data: `${d}${c ? c.replace("0x", "") : ""}`,
-      to: r,
-      ...t
-    });
-  } catch (n) {
-    const a = t.account ? f(t.account) : void 0;
-    throw p(n, {
-      abi: o,
-      address: r,
-      args: e,
-      docsPath: "/docs/contract/estimateContractGas",
-      functionName: s,
-      sender: a == null ? void 0 : a.address
-    });
-  }
+function e(r) {
+  return typeof r == "string" ? { address: r, type: "json-rpc" } : r;
 }
 export {
-  A as estimateContractGas
+  e as parseAccount
 };