@7kprotocol/sdk-ts 3.4.2-beta.3 → 3.4.2-beta.5

package/lib/esm/utils/ObjectCache.js

@@ -0,0 +1,250 @@
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+export class AsyncCache {
+    async getObject(id) {
+        const [owned, shared] = await Promise.all([
+            this.get("OwnedObject", id),
+            this.get("SharedOrImmutableObject", id),
+        ]);
+        return owned ?? shared ?? null;
+    }
+    async getObjects(ids) {
+        return Promise.all(ids.map((id) => this.getObject(id)));
+    }
+    async addObject(object) {
+        if (object.owner) {
+            await this.set("OwnedObject", object.objectId, object);
+        }
+        else {
+            await this.set("SharedOrImmutableObject", object.objectId, object);
+        }
+        return object;
+    }
+    async addObjects(objects) {
+        await Promise.all(objects.map(async (object) => this.addObject(object)));
+    }
+    async deleteObject(id) {
+        await Promise.all([
+            this.delete("OwnedObject", id),
+            this.delete("SharedOrImmutableObject", id),
+        ]);
+    }
+    async deleteObjects(ids) {
+        await Promise.all(ids.map((id) => this.deleteObject(id)));
+    }
+    async getMoveFunctionDefinition(ref) {
+        const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`;
+        return this.get("MoveFunction", functionName);
+    }
+    async addMoveFunctionDefinition(functionEntry) {
+        const pkg = normalizeSuiAddress(functionEntry.package);
+        const functionName = `${pkg}::${functionEntry.module}::${functionEntry.function}`;
+        const entry = {
+            ...functionEntry,
+            package: pkg,
+        };
+        await this.set("MoveFunction", functionName, entry);
+        return entry;
+    }
+    async deleteMoveFunctionDefinition(ref) {
+        const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`;
+        await this.delete("MoveFunction", functionName);
+    }
+    async getCustom(key) {
+        return this.get("Custom", key);
+    }
+    async setCustom(key, value) {
+        return this.set("Custom", key, value);
+    }
+    async deleteCustom(key) {
+        return this.delete("Custom", key);
+    }
+}
+export class InMemoryObjectCache extends AsyncCache {
+    #caches = {
+        OwnedObject: new Map(),
+        SharedOrImmutableObject: new Map(),
+        MoveFunction: new Map(),
+        Custom: new Map(),
+    };
+    async get(type, key) {
+        return this.#caches[type].get(key) ?? null;
+    }
+    async set(type, key, value) {
+        this.#caches[type].set(key, value);
+    }
+    async delete(type, key) {
+        this.#caches[type].delete(key);
+    }
+    async clear(type) {
+        if (type) {
+            this.#caches[type].clear();
+        }
+        else {
+            for (const cache of Object.values(this.#caches)) {
+                cache.clear();
+            }
+        }
+    }
+}
+export class CustomObjectCache {
+    #client;
+    #cache;
+    #onEffects;
+    constructor({ cache = new InMemoryObjectCache(), onEffects, client, }) {
+        this.#client = client;
+        this.#cache = cache;
+        this.#onEffects = onEffects;
+    }
+    async applyCache(transactionData, unresolvedObjects) {
+        const cached = (await this.#cache.getObjects(unresolvedObjects)).filter((obj) => obj !== null);
+        const byId = new Map(cached.map((obj) => [obj.objectId, obj]));
+        const unresolved = [];
+        for (const input of transactionData.inputs) {
+            if (!input.UnresolvedObject) {
+                continue;
+            }
+            const cached = byId.get(input.UnresolvedObject.objectId);
+            if (!cached) {
+                unresolved.push(input.UnresolvedObject.objectId);
+                continue;
+            }
+            if (cached.initialSharedVersion &&
+                !input.UnresolvedObject.initialSharedVersion) {
+                input.UnresolvedObject.initialSharedVersion =
+                    cached.initialSharedVersion;
+            }
+            else {
+                if (cached.version && !input.UnresolvedObject.version) {
+                    input.UnresolvedObject.version = cached.version;
+                }
+                if (cached.digest && !input.UnresolvedObject.digest) {
+                    input.UnresolvedObject.digest = cached.digest;
+                }
+            }
+        }
+        return unresolved;
+    }
+    async resolveObjects(transactionData, unresolved) {
+        const unresolvedObjects = await this.applyCache(transactionData, unresolved);
+        if (unresolvedObjects.length === 0) {
+            return [];
+        }
+        const dedup = [...new Set(unresolvedObjects)];
+        const res = await this.#client.multiGetObjects({
+            ids: dedup,
+            options: {
+                showOwner: true,
+            },
+        });
+        const objects = [];
+        for (const obj of res || []) {
+            if (!obj.data) {
+                continue;
+            }
+            const owner = obj.data.owner;
+            const initialSharedVersion = owner && typeof owner === "object" && "Shared" in owner
+                ? owner.Shared.initial_shared_version
+                : null;
+            const ownerAddress = owner && typeof owner === "object" && "AddressOwner" in owner
+                ? owner.AddressOwner
+                : null;
+            const cached = {
+                objectId: obj.data.objectId,
+                version: obj.data.version,
+                digest: obj.data.digest,
+                initialSharedVersion,
+                owner: ownerAddress,
+            };
+            objects.push(cached);
+        }
+        await this.#cache.addObjects(objects);
+        return await this.applyCache(transactionData, unresolvedObjects);
+    }
+    asPlugin() {
+        return async (transactionData, _options, next) => {
+            const unresolvedObjects = transactionData.inputs
+                .filter((input) => input.UnresolvedObject)
+                .map((input) => input.UnresolvedObject.objectId);
+            // if object is not in cache yet, fetch from RPC and save to cache and resolve all objects
+            await this.resolveObjects(transactionData, unresolvedObjects);
+            await Promise.all(transactionData.commands.map(async (commands) => {
+                if (commands.MoveCall) {
+                    const def = await this.getMoveFunctionDefinition({
+                        package: commands.MoveCall.package,
+                        module: commands.MoveCall.module,
+                        function: commands.MoveCall.function,
+                    });
+                    if (def) {
+                        commands.MoveCall._argumentTypes = def.parameters;
+                    }
+                }
+            }));
+            await next();
+            await Promise.all(transactionData.commands.map(async (commands) => {
+                if (commands.MoveCall?._argumentTypes) {
+                    await this.#cache.addMoveFunctionDefinition({
+                        package: commands.MoveCall.package,
+                        module: commands.MoveCall.module,
+                        function: commands.MoveCall.function,
+                        parameters: commands.MoveCall._argumentTypes,
+                    });
+                }
+            }));
+        };
+    }
+    async clear() {
+        await this.#cache.clear();
+    }
+    async getMoveFunctionDefinition(ref) {
+        return this.#cache.getMoveFunctionDefinition(ref);
+    }
+    async getObjects(ids) {
+        return this.#cache.getObjects(ids);
+    }
+    async deleteObjects(ids) {
+        return this.#cache.deleteObjects(ids);
+    }
+    async clearOwnedObjects() {
+        await this.#cache.clear("OwnedObject");
+    }
+    async clearCustom() {
+        await this.#cache.clear("Custom");
+    }
+    async getCustom(key) {
+        return this.#cache.getCustom(key);
+    }
+    async setCustom(key, value) {
+        return this.#cache.setCustom(key, value);
+    }
+    async deleteCustom(key) {
+        return this.#cache.deleteCustom(key);
+    }
+    async applyEffects(effects) {
+        if (!effects.V2) {
+            throw new Error(`Unsupported transaction effects version ${effects.$kind}`);
+        }
+        const { lamportVersion, changedObjects } = effects.V2;
+        const deletedIds = [];
+        const addedObjects = [];
+        changedObjects.forEach(([id, change]) => {
+            if (change.outputState.NotExist) {
+                deletedIds.push(id);
+            }
+            else if (change.outputState.ObjectWrite) {
+                const [digest, owner] = change.outputState.ObjectWrite;
+                addedObjects.push({
+                    objectId: id,
+                    digest,
+                    version: lamportVersion,
+                    owner: owner.AddressOwner ?? owner.ObjectOwner ?? null,
+                    initialSharedVersion: owner.Shared?.initialSharedVersion ?? null,
+                });
+            }
+        });
+        await Promise.all([
+            this.#cache.addObjects(addedObjects),
+            this.#cache.deleteObjects(deletedIds),
+            this.#onEffects?.(effects),
+        ]);
+    }
+}

package/lib/esm/utils/SuiClientUtils.js

@@ -0,0 +1,34 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { CustomObjectCache } from "./ObjectCache";
+/**
+ * Utility class for interacting with Sui blockchain coins
+ */
+export class SuiClientUtils {
+    client;
+    #devInspectCache;
+    /**
+     * Creates a new instance of SuiClientUtils
+     * @param client - The Sui client instance to use for blockchain interactions
+     */
+    constructor(client) {
+        this.client = client;
+        this.#devInspectCache = new CustomObjectCache({ client: this.client });
+    }
+    devInspectTransactionBlock = async (params) => {
+        if (params.transactionBlock instanceof Transaction) {
+            params.transactionBlock.addBuildPlugin(this.#devInspectCache.asPlugin());
+        }
+        try {
+            const res = await this.client.devInspectTransactionBlock(params);
+            return res;
+        }
+        catch (error) {
+            // clear all cache if devInspectTransactionBlock fails
+            await this.#devInspectCache.clear();
+            throw error;
+        }
+        finally {
+            await this.#devInspectCache.clearOwnedObjects();
+        }
+    };
+}

package/lib/esm/utils/condition.js

@@ -0,0 +1,5 @@
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7kprotocol/sdk-ts",
-  "version": "3.4.2-beta.3",
+  "version": "3.4.2-beta.5",
   "description": "",
   "exports": {
     ".": {
@@ -73,5 +73,12 @@
   "peerDependencies": {
     "@mysten/sui": "^1.39.0",
     "@pythnetwork/pyth-sui-js": "^2.2.0"
+  },
+  "dependencies": {
+    "uuid": "^13.0.0"
+  },
+  "optionalDependencies": {
+    "@cetusprotocol/aggregator-sdk": "^1.4.1",
+    "@flowx-finance/sdk": "^1.13.8"
   }
 }