@suilend/sdk 1.0.0

package/mainnet/utils/utils.d.ts

@@ -0,0 +1,79 @@
+import { SerializedBcs } from "@mysten/bcs";
+import { SharedObjectRef } from "@mysten/sui.js/bcs";
+import { SuiObjectRef } from "@mysten/sui.js/client";
+import { TransactionArgument, TransactionBlock } from "@mysten/sui.js/transactions";
+export type TransactionObjectArgument = Exclude<TransactionArgument, {
+    kind: "Input";
+    type: "pure";
+}>;
+/**
+ * These are the basics types that can be used in SUI
+ */
+export type SuiBasicTypes = "address" | "bool" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "signer";
+export type SuiAddressArg = TransactionArgument | SerializedBcs<any> | string;
+export type SuiTxArg = SuiAddressArg | number | bigint | boolean;
+export type SuiInputTypes = "object" | SuiBasicTypes;
+export type SuiObjectArg = TransactionObjectArgument | string | SharedObjectRef | SuiObjectRef;
+export type SuiVecTxArg = {
+    value: SuiTxArg[];
+    vecType: SuiInputTypes;
+} | SuiTxArg[];
+export declare function takeAmountFromCoins(txBlock: TransactionBlock, coins: SuiObjectArg[], amount: SuiTxArg): TransactionObjectArgument[];
+export declare function splitSUIFromGas(txBlock: TransactionBlock, amounts: SuiTxArg[]): import("@mysten/sui.js/transactions").TransactionResult;
+/**
+ * Convert any valid input into array of TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param args The array of argument to convert.
+ * @returns The converted array of TransactionArgument.
+ */
+export declare function convertArgs(txBlock: TransactionBlock, args: (SuiTxArg | SuiVecTxArg)[]): ({
+    index: number;
+    kind: "Input";
+    type?: "object" | undefined;
+    value?: any;
+} | {
+    type: "pure";
+    index: number;
+    kind: "Input";
+    value?: any;
+} | {
+    kind: "GasCoin";
+} | {
+    index: number;
+    kind: "Result";
+} | {
+    index: number;
+    resultIndex: number;
+    kind: "NestedResult";
+} | SerializedBcs<unknown, unknown> | (SerializedBcs<any, any> & import("@mysten/sui.js/bcs").PureArg))[];
+/**
+ * Convert any valid object input into a TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param arg The object argument to convert.
+ * @returns The converted TransactionArgument.
+ */
+export declare function convertObjArg(txb: TransactionBlock, arg: SuiObjectArg): TransactionObjectArgument;
+/**
+ * Check whether it is an valid move vec input.
+ *
+ * @param arg The argument to check.
+ * @returns boolean.
+ */
+export declare function isMoveVecArg(arg: SuiTxArg | SuiVecTxArg): arg is SuiVecTxArg;
+export declare const getDefaultSuiInputType: (value: SuiTxArg) => SuiInputTypes | undefined;
+/**
+ * Since we know the elements in the array are the same type
+ * If type is not provided, we will try to infer the type from the first element
+ * By default,
+ *
+ * string is hex and its length equal to 32 =====> object id
+ * number, bigint ====> u64
+ * boolean =====> bool
+ *
+ * If type is provided, we will use the type to convert the array
+ * @param args
+ * @param type 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'signer' | 'object' | string
+ */
+export declare function makeVecParam(txBlock: TransactionBlock, args: SuiTxArg[], type?: SuiInputTypes): TransactionArgument;

package/mainnet/utils/utils.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeVecParam = exports.getDefaultSuiInputType = exports.isMoveVecArg = exports.convertObjArg = exports.convertArgs = exports.splitSUIFromGas = exports.takeAmountFromCoins = void 0;
+const bcs_1 = require("@mysten/bcs");
+const bcs_2 = require("@mysten/sui.js/bcs");
+const transactions_1 = require("@mysten/sui.js/transactions");
+const utils_1 = require("@mysten/sui.js/utils");
+function takeAmountFromCoins(txBlock, coins, amount) {
+    const coinObjects = coins.map((coin) => convertObjArg(txBlock, coin));
+    const mergedCoin = coinObjects[0];
+    if (coins.length > 1) {
+        txBlock.mergeCoins(mergedCoin, coinObjects.slice(1));
+    }
+    const [sendCoin] = txBlock.splitCoins(mergedCoin, convertArgs(txBlock, [amount]));
+    return [sendCoin, mergedCoin];
+}
+exports.takeAmountFromCoins = takeAmountFromCoins;
+function splitSUIFromGas(txBlock, amounts) {
+    return txBlock.splitCoins(txBlock.gas, convertArgs(txBlock, amounts));
+}
+exports.splitSUIFromGas = splitSUIFromGas;
+/**
+ * Convert any valid input into array of TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param args The array of argument to convert.
+ * @returns The converted array of TransactionArgument.
+ */
+function convertArgs(txBlock, args) {
+    return args.map((arg) => {
+        if (typeof arg === "string" && (0, utils_1.isValidSuiObjectId)(arg)) {
+            return txBlock.object((0, utils_1.normalizeSuiObjectId)(arg));
+        }
+        else if (typeof arg == "object" &&
+            !(0, bcs_1.isSerializedBcs)(arg) &&
+            !(0, bcs_2.isPureArg)(arg) &&
+            !isMoveVecArg(arg)) {
+            return convertObjArg(txBlock, arg);
+        }
+        else if (isMoveVecArg(arg)) {
+            const vecType = "vecType" in arg;
+            return vecType
+                ? makeVecParam(txBlock, arg.value, arg.vecType)
+                : makeVecParam(txBlock, arg);
+        }
+        else if ((0, bcs_1.isSerializedBcs)(arg)) {
+            return arg;
+        }
+        else {
+            return txBlock.pure(arg);
+        }
+    });
+}
+exports.convertArgs = convertArgs;
+/**
+ * Convert any valid object input into a TransactionArgument.
+ *
+ * @param txb The Transaction Block
+ * @param arg The object argument to convert.
+ * @returns The converted TransactionArgument.
+ */
+function convertObjArg(txb, arg) {
+    if (typeof arg === "string") {
+        return txb.object(arg);
+    }
+    if ("digest" in arg && "version" in arg && "objectId" in arg) {
+        return txb.objectRef(arg);
+    }
+    if ("objectId" in arg && "initialSharedVersion" in arg && "mutable" in arg) {
+        return txb.sharedObjectRef(arg);
+    }
+    if ("Object" in arg) {
+        if ("ImmOrOwned" in arg.Object) {
+            return txb.object(transactions_1.Inputs.ObjectRef(arg.Object.ImmOrOwned));
+        }
+        else if ("Shared" in arg.Object) {
+            return txb.object(transactions_1.Inputs.SharedObjectRef(arg.Object.Shared));
+        }
+        else {
+            throw new Error("Invalid argument type");
+        }
+    }
+    if ("kind" in arg) {
+        return arg;
+    }
+    throw new Error("Invalid argument type");
+}
+exports.convertObjArg = convertObjArg;
+/**
+ * Check whether it is an valid move vec input.
+ *
+ * @param arg The argument to check.
+ * @returns boolean.
+ */
+function isMoveVecArg(arg) {
+    if (typeof arg === "object" && "vecType" in arg && "value" in arg) {
+        return true;
+    }
+    else if (Array.isArray(arg)) {
+        return true;
+    }
+    return false;
+}
+exports.isMoveVecArg = isMoveVecArg;
+const getDefaultSuiInputType = (value) => {
+    if (typeof value === "string" && (0, utils_1.isValidSuiObjectId)(value)) {
+        return "object";
+    }
+    else if (typeof value === "number" || typeof value === "bigint") {
+        return "u64";
+    }
+    else if (typeof value === "boolean") {
+        return "bool";
+    }
+    else {
+        return undefined;
+    }
+};
+exports.getDefaultSuiInputType = getDefaultSuiInputType;
+/**
+ * Since we know the elements in the array are the same type
+ * If type is not provided, we will try to infer the type from the first element
+ * By default,
+ *
+ * string is hex and its length equal to 32 =====> object id
+ * number, bigint ====> u64
+ * boolean =====> bool
+ *
+ * If type is provided, we will use the type to convert the array
+ * @param args
+ * @param type 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'signer' | 'object' | string
+ */
+function makeVecParam(txBlock, args, type) {
+    if (args.length === 0)
+        throw new Error("Transaction builder error: Empty array is not allowed");
+    // Using first element value as default type
+    const defaultSuiType = (0, exports.getDefaultSuiInputType)(args[0]);
+    const VECTOR_REGEX = /^vector<(.+)>$/;
+    const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+    type = type || defaultSuiType;
+    if (type === "object") {
+        const objects = args.map((arg) => typeof arg === "string" && (0, utils_1.isValidSuiObjectId)(arg)
+            ? txBlock.object((0, utils_1.normalizeSuiObjectId)(arg))
+            : convertObjArg(txBlock, arg));
+        return txBlock.makeMoveVec({ objects });
+    }
+    else if (typeof type === "string" &&
+        !VECTOR_REGEX.test(type) &&
+        !STRUCT_REGEX.test(type)) {
+        return txBlock.pure(args, `vector<${type}>`);
+    }
+    else {
+        const objects = args.map((arg) => convertObjArg(txBlock, arg));
+        return txBlock.makeMoveVec({ objects, type });
+    }
+}
+exports.makeVecParam = makeVecParam;

package/mainnet/utils.d.ts

@@ -0,0 +1 @@
+export * from "../core/utils";

package/mainnet/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../core/utils"), exports);

package/package.json

@@ -0,0 +1 @@
+{"name":"@suilend/sdk","version":"1.0.0","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./*":"./*/*.js"},"types":"./index.js","scripts":{"build":"rm -rf ./dist && bun tsc","eslint":"eslint --fix \"./src/**/*.ts\"","prettier":"prettier --write \"./src/**/*\"","lint":"bun eslint && bun prettier","release":"bun run build && bun ts-node ./prepublish.ts && cd ./dist && npm publish --access public"},"repository":{"type":"git","url":"git+https://github.com/solendprotocol/suilend-public.git"},"bugs":{"url":"https://github.com/solendprotocol/suilend-public/issues"},"homepage":"https://github.com/solendprotocol/suilend-public/tree/HEAD/sdk#readme","dependencies":{"@mysten/bcs":"^0.10.1","@mysten/sui.js":"^0.49.1","bignumber.js":"^9.1.2","uuid":"^9.0.1"},"devDependencies":{"@types/node":"^20.12.7","ts-node":"^10.9.2","typescript":"^5.3.3"}}

package/pyth-sdk/SuiPriceServiceConnection.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { PriceServiceConnection, HexString } from "@pythnetwork/price-service-client";
+import { Buffer } from "buffer";
+export declare class SuiPriceServiceConnection extends PriceServiceConnection {
+    /**
+     * Gets price update data (either batch price attestation VAAs or accumulator messages, depending on the chosen endpoint), which then
+     * can be submitted to the Pyth contract to update the prices. This will throw an axios error if there is a network problem or
+     * the price service returns a non-ok response (e.g: Invalid price ids)
+     *
+     * @param priceIds Array of hex-encoded price ids.
+     * @returns Array of buffers containing the price update data.
+     */
+    getPriceFeedsUpdateData(priceIds: HexString[]): Promise<Buffer[]>;
+}

package/pyth-sdk/SuiPriceServiceConnection.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiPriceServiceConnection = void 0;
+const price_service_client_1 = require("@pythnetwork/price-service-client");
+const buffer_1 = require("buffer");
+class SuiPriceServiceConnection extends price_service_client_1.PriceServiceConnection {
+    /**
+     * Gets price update data (either batch price attestation VAAs or accumulator messages, depending on the chosen endpoint), which then
+     * can be submitted to the Pyth contract to update the prices. This will throw an axios error if there is a network problem or
+     * the price service returns a non-ok response (e.g: Invalid price ids)
+     *
+     * @param priceIds Array of hex-encoded price ids.
+     * @returns Array of buffers containing the price update data.
+     */
+    getPriceFeedsUpdateData(priceIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Fetch the latest price feed update VAAs from the price service
+            const latestVaas = yield this.getLatestVaas(priceIds);
+            return latestVaas.map((vaa) => buffer_1.Buffer.from(vaa, "base64"));
+        });
+    }
+}
+exports.SuiPriceServiceConnection = SuiPriceServiceConnection;

package/pyth-sdk/client.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { SuiClient } from "@mysten/sui.js/client";
+import { HexString } from "@pythnetwork/price-service-client";
+import { Buffer } from "buffer";
+export declare class SuiPythClient {
+    client: SuiClient;
+    pythStateId: string;
+    wormholeStateId: string;
+    private pythPackageId;
+    private wormholePackageId;
+    private priceTableInfo;
+    private priceFeedObjectIdCache;
+    private baseUpdateFee;
+    constructor(client: SuiClient, pythStateId: string, wormholeStateId: string);
+    getBaseUpdateFee(): Promise<number>;
+    /**
+     * getPackageId returns the latest package id that the object belongs to. Use this to
+     * fetch the latest package id for a given object id and handle package upgrades automatically.
+     * @param objectId
+     * @returns package id
+     */
+    getPackageId(objectId: string): Promise<string>;
+    /**
+     * Adds the commands for calling wormhole and verifying the vaas and returns the verified vaas.
+     * @param vaas array of vaas to verify
+     * @param tx transaction block to add commands to
+     */
+    verifyVaas(vaas: Buffer[], tx: TransactionBlock): Promise<{
+        index: number;
+        resultIndex: number;
+        kind: "NestedResult";
+    }[]>;
+    /**
+     * Adds the necessary commands for updating the pyth price feeds to the transaction block.
+     * @param tx transaction block to add commands to
+     * @param updates array of price feed updates received from the price service
+     * @param feedIds array of feed ids to update (in hex format)
+     */
+    updatePriceFeeds(tx: TransactionBlock, updates: Buffer[], feedIds: HexString[]): Promise<string[]>;
+    createPriceFeed(tx: TransactionBlock, updates: Buffer[]): Promise<void>;
+    /**
+     * Get the packageId for the wormhole package if not already cached
+     */
+    getWormholePackageId(): Promise<string>;
+    /**
+     * Get the packageId for the pyth package if not already cached
+     */
+    getPythPackageId(): Promise<string>;
+    /**
+     * Get the priceFeedObjectId for a given feedId if not already cached
+     * @param feedId
+     */
+    getPriceFeedObjectId(feedId: HexString): Promise<string | undefined>;
+    /**
+     * Fetches the price table object id for the current state id if not cached
+     * @returns price table object id
+     */
+    getPriceTableInfo(): Promise<{
+        id: string;
+        fieldType: string;
+    }>;
+    /**
+     * Checks if a message is an accumulator message or not
+     * @param msg - update message from price service
+     */
+    isAccumulatorMsg(msg: Buffer): boolean;
+    /**
+     * Obtains the vaa bytes embedded in an accumulator message.
+     * @param accumulatorMessage - the accumulator price update message
+     * @returns vaa bytes as a uint8 array
+     */
+    extractVaaBytesFromAccumulatorMessage(accumulatorMessage: Buffer): Buffer;
+}