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

package/lib/esm/utils/ObjectCache.js

@@ -1,250 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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/sui.js

@@ -1,92 +0,0 @@
-import { normalizeSuiAddress, parseStructTag } from "@mysten/sui/utils";
-import { _7K_META_CONFIG, _7K_META_PACKAGE_ID, _7K_META_VAULT, } from "../constants/_7k";
-export const SuiUtils = {
-    getSuiCoin(amount, txb) {
-        const [coin] = txb.splitCoins(txb.gas, [amount]);
-        return coin;
-    },
-    getCoinValue(coinType, coinObject, txb) {
-        const inputCoinObject = typeof coinObject == "string" ? txb.object(coinObject) : coinObject;
-        const [value] = txb.moveCall({
-            target: `0x2::coin::value`,
-            typeArguments: [coinType],
-            arguments: [inputCoinObject],
-        });
-        return value;
-    },
-    isValidStructTag(value) {
-        try {
-            return !!parseStructTag(value);
-        }
-        catch (_) {
-            return false;
-        }
-    },
-    zeroBalance(tx, coinType) {
-        return tx.moveCall({
-            target: `0x2::balance::zero`,
-            typeArguments: [coinType],
-            arguments: [],
-        })[0];
-    },
-    zeroCoin(tx, coinType) {
-        return tx.moveCall({
-            target: `0x2::coin::zero`,
-            typeArguments: [coinType],
-            arguments: [],
-        })[0];
-    },
-    coinIntoBalance(tx, coinType, coinObject) {
-        return tx.moveCall({
-            target: `0x2::coin::into_balance`,
-            typeArguments: [coinType],
-            arguments: [coinObject],
-        })[0];
-    },
-    coinFromBalance(tx, coinType, balance) {
-        return tx.moveCall({
-            target: `0x2::coin::from_balance`,
-            typeArguments: [coinType],
-            arguments: [balance],
-        })[0];
-    },
-    balanceDestroyZero(tx, coinType, balance) {
-        tx.moveCall({
-            target: `0x2::balance::destroy_zero`,
-            typeArguments: [coinType],
-            arguments: [balance],
-        });
-    },
-    collectDust(tx, coinType, coin) {
-        tx.moveCall({
-            target: `${_7K_META_PACKAGE_ID}::vault::collect_dust`,
-            typeArguments: [coinType],
-            arguments: [tx.object(_7K_META_VAULT), tx.object(_7K_META_CONFIG), coin],
-        });
-    },
-    transferOrDestroyZeroCoin(tx, coinType, coin, address) {
-        tx.moveCall({
-            target: `${_7K_META_PACKAGE_ID}::utils::transfer_or_destroy`,
-            typeArguments: [coinType],
-            arguments: [coin, tx.pure.address(address)],
-        });
-    },
-};
-export const isSystemAddress = (address) => {
-    const addr = normalizeSuiAddress(address);
-    const addresses = [
-        "0x0", // zero
-        "0x1", // std
-        "0x2", // sui framework
-        "0x3", // unkown but we reserved to be safe
-        "0x4", // unknown but we reserved to be safe
-        "0x5", // system state
-        "0x6", // time
-        "0x7", // unknown but we reserved to be safe
-        "0x8", // random
-        "0x9", // unknown but we reserved to be safe
-        "0x403", // coin deny list
-        "0xc", // coin registry
-    ].map((v) => normalizeSuiAddress(v));
-    return addresses.includes(addr);
-};

package/lib/esm/utils/swap.js

@@ -1,33 +0,0 @@
-/**
- * Calculate expected return amount after applying slippage, commission, and tip
- * @param returnAmount - The raw return amount (with decimals)
- * @param slippageBps - Slippage in basis points (1 bps = 0.01%)
- * @param commissionBps - Commission in basis points
- * @param tipBps - Tip in basis points (default: 0)
- * @returns Object containing tipAmount, minAmount, commissionAmount, and expectedAmount
- */
-export const getExpectedReturn = (returnAmount, slippageBps, commissionBps, tipBps = 0) => {
-    if (slippageBps > 10000) {
-        throw new Error("Slippage must be less than 100%");
-    }
-    if (commissionBps > 10000) {
-        throw new Error("Commission must be less than 100%");
-    }
-    if (tipBps > 10000) {
-        throw new Error("Tip must be less than 100%");
-    }
-    const returnAmountWithDecimal = BigInt(returnAmount);
-    const tipAmountWithDecimal = (returnAmountWithDecimal * BigInt(tipBps || 0)) / 10000n;
-    const commissionAmountWithDecimal = ((returnAmountWithDecimal - tipAmountWithDecimal) * BigInt(commissionBps)) /
-        10000n;
-    const expectedReturnWithDecimal = returnAmountWithDecimal -
-        tipAmountWithDecimal -
-        commissionAmountWithDecimal;
-    const minAmountWithDecimal = (expectedReturnWithDecimal * BigInt(1e4 - slippageBps)) / 10000n;
-    return {
-        tipAmount: tipAmountWithDecimal,
-        minAmount: minAmountWithDecimal,
-        commissionAmount: commissionAmountWithDecimal,
-        expectedAmount: expectedReturnWithDecimal.toString(10),
-    };
-};

package/lib/esm/utils/token.js

@@ -1,10 +0,0 @@
-import { SUI_FULL_TYPE, SUI_TYPE } from "../constants/tokens";
-export function normalizeTokenType(type) {
-    return type === SUI_TYPE ? SUI_FULL_TYPE : type;
-}
-export function denormalizeTokenType(type) {
-    return type === SUI_FULL_TYPE ? SUI_TYPE : type;
-}
-export function checkIsSui(type) {
-    return type === SUI_FULL_TYPE || type === SUI_TYPE;
-}