@suilend/sdk 1.0.0

package/pyth-sdk/client.js

@@ -0,0 +1,322 @@
+"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.SuiPythClient = void 0;
+const utils_1 = require("@mysten/sui.js/utils");
+const bcs_1 = require("@mysten/bcs");
+const buffer_1 = require("buffer");
+const MAX_ARGUMENT_SIZE = 16 * 1024;
+class SuiPythClient {
+    constructor(client, pythStateId, wormholeStateId) {
+        this.client = client;
+        this.pythStateId = pythStateId;
+        this.wormholeStateId = wormholeStateId;
+        this.priceFeedObjectIdCache = new Map();
+        this.pythPackageId = undefined;
+        this.wormholePackageId = undefined;
+    }
+    getBaseUpdateFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.baseUpdateFee === undefined) {
+                const result = yield this.client.getObject({
+                    id: this.pythStateId,
+                    options: { showContent: true },
+                });
+                if (!result.data ||
+                    !result.data.content ||
+                    result.data.content.dataType !== "moveObject")
+                    throw new Error("Unable to fetch pyth state object");
+                this.baseUpdateFee = result.data.content.fields
+                    .base_update_fee;
+            }
+            return this.baseUpdateFee;
+        });
+    }
+    /**
+     * 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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.client
+                .getObject({
+                id: objectId,
+                options: {
+                    showContent: true,
+                },
+            })
+                .then((result) => {
+                var _a, _b;
+                if (((_b = (_a = result.data) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.dataType) == "moveObject") {
+                    return result.data.content.fields;
+                }
+                throw new Error("not move object");
+            });
+            if ("upgrade_cap" in state) {
+                return state.upgrade_cap.fields.package;
+            }
+            throw new Error("upgrade_cap not found");
+        });
+    }
+    /**
+     * 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, tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wormholePackageId = yield this.getWormholePackageId();
+            const verifiedVaas = [];
+            for (const vaa of vaas) {
+                const [verifiedVaa] = tx.moveCall({
+                    target: `${wormholePackageId}::vaa::parse_and_verify`,
+                    arguments: [
+                        tx.object(this.wormholeStateId),
+                        tx.pure(new bcs_1.BCS((0, bcs_1.getSuiMoveConfig)())
+                            .ser("vector<u8>", Array.from(vaa), {
+                            maxSize: MAX_ARGUMENT_SIZE,
+                        })
+                            .toBytes()),
+                        tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ],
+                });
+                verifiedVaas.push(verifiedVaa);
+            }
+            return verifiedVaas;
+        });
+    }
+    /**
+     * 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, updates, feedIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wormholePackageId = yield this.getWormholePackageId();
+            const packageId = yield this.getPythPackageId();
+            let priceUpdatesHotPotato;
+            if (updates.every((update) => this.isAccumulatorMsg(update))) {
+                if (updates.length > 1) {
+                    throw new Error("SDK does not support sending multiple accumulator messages in a single transaction");
+                }
+                const vaa = this.extractVaaBytesFromAccumulatorMessage(updates[0]);
+                const verifiedVaas = yield this.verifyVaas([vaa], tx);
+                [priceUpdatesHotPotato] = tx.moveCall({
+                    target: `${packageId}::pyth::create_authenticated_price_infos_using_accumulator`,
+                    arguments: [
+                        tx.object(this.pythStateId),
+                        tx.pure(new bcs_1.BCS((0, bcs_1.getSuiMoveConfig)())
+                            .ser("vector<u8>", Array.from(updates[0]), {
+                            maxSize: MAX_ARGUMENT_SIZE,
+                        })
+                            .toBytes()),
+                        verifiedVaas[0],
+                        tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ],
+                });
+            }
+            else if (updates.every((vaa) => !this.isAccumulatorMsg(vaa))) {
+                const verifiedVaas = yield this.verifyVaas(updates, tx);
+                [priceUpdatesHotPotato] = tx.moveCall({
+                    target: `${packageId}::pyth::create_price_infos_hot_potato`,
+                    arguments: [
+                        tx.object(this.pythStateId),
+                        tx.makeMoveVec({
+                            type: `${wormholePackageId}::vaa::VAA`,
+                            objects: verifiedVaas,
+                        }),
+                        tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ],
+                });
+            }
+            else {
+                throw new Error("Can't mix accumulator and non-accumulator messages");
+            }
+            const priceInfoObjects = [];
+            const baseUpdateFee = yield this.getBaseUpdateFee();
+            const coins = tx.splitCoins(tx.gas, feedIds.map(() => tx.pure(baseUpdateFee)));
+            let coinId = 0;
+            for (const feedId of feedIds) {
+                const priceInfoObjectId = yield this.getPriceFeedObjectId(feedId);
+                if (!priceInfoObjectId) {
+                    throw new Error(`Price feed ${feedId} not found, please create it first`);
+                }
+                priceInfoObjects.push(priceInfoObjectId);
+                [priceUpdatesHotPotato] = tx.moveCall({
+                    target: `${packageId}::pyth::update_single_price_feed`,
+                    arguments: [
+                        tx.object(this.pythStateId),
+                        priceUpdatesHotPotato,
+                        tx.object(priceInfoObjectId),
+                        coins[coinId],
+                        tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ],
+                });
+                coinId++;
+            }
+            tx.moveCall({
+                target: `${packageId}::hot_potato_vector::destroy`,
+                arguments: [priceUpdatesHotPotato],
+                typeArguments: [`${packageId}::price_info::PriceInfo`],
+            });
+            return priceInfoObjects;
+        });
+    }
+    createPriceFeed(tx, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wormholePackageId = yield this.getWormholePackageId();
+            const packageId = yield this.getPythPackageId();
+            if (updates.every((update) => this.isAccumulatorMsg(update))) {
+                if (updates.length > 1) {
+                    throw new Error("SDK does not support sending multiple accumulator messages in a single transaction");
+                }
+                const vaa = this.extractVaaBytesFromAccumulatorMessage(updates[0]);
+                const verifiedVaas = yield this.verifyVaas([vaa], tx);
+                tx.moveCall({
+                    target: `${packageId}::pyth::create_price_feeds_using_accumulator`,
+                    arguments: [
+                        tx.object(this.pythStateId),
+                        tx.pure(new bcs_1.BCS((0, bcs_1.getSuiMoveConfig)())
+                            .ser("vector<u8>", Array.from(updates[0]), {
+                            maxSize: MAX_ARGUMENT_SIZE,
+                        })
+                            .toBytes()),
+                        verifiedVaas[0],
+                        tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ],
+                });
+            }
+            else if (updates.every((vaa) => !this.isAccumulatorMsg(vaa))) {
+                const verifiedVaas = yield this.verifyVaas(updates, tx);
+                tx.moveCall({
+                    target: `${packageId}::pyth::create_price_feeds`,
+                    arguments: [
+                        tx.object(this.pythStateId),
+                        tx.makeMoveVec({
+                            type: `${wormholePackageId}::vaa::VAA`,
+                            objects: verifiedVaas,
+                        }),
+                        tx.object(utils_1.SUI_CLOCK_OBJECT_ID),
+                    ],
+                });
+            }
+            else {
+                throw new Error("Can't mix accumulator and non-accumulator messages");
+            }
+        });
+    }
+    /**
+     * Get the packageId for the wormhole package if not already cached
+     */
+    getWormholePackageId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.wormholePackageId) {
+                this.wormholePackageId = yield this.getPackageId(this.wormholeStateId);
+            }
+            return this.wormholePackageId;
+        });
+    }
+    /**
+     * Get the packageId for the pyth package if not already cached
+     */
+    getPythPackageId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.pythPackageId) {
+                this.pythPackageId = yield this.getPackageId(this.pythStateId);
+            }
+            return this.pythPackageId;
+        });
+    }
+    /**
+     * Get the priceFeedObjectId for a given feedId if not already cached
+     * @param feedId
+     */
+    getPriceFeedObjectId(feedId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalizedFeedId = feedId.replace("0x", "");
+            if (!this.priceFeedObjectIdCache.has(normalizedFeedId)) {
+                const { id: tableId, fieldType } = yield this.getPriceTableInfo();
+                const result = yield this.client.getDynamicFieldObject({
+                    parentId: tableId,
+                    name: {
+                        type: `${fieldType}::price_identifier::PriceIdentifier`,
+                        value: {
+                            bytes: Array.from(buffer_1.Buffer.from(normalizedFeedId, "hex")),
+                        },
+                    },
+                });
+                if (!result.data || !result.data.content) {
+                    return undefined;
+                }
+                if (result.data.content.dataType !== "moveObject") {
+                    throw new Error("Price feed type mismatch");
+                }
+                this.priceFeedObjectIdCache.set(normalizedFeedId, result.data.content.fields.value);
+            }
+            return this.priceFeedObjectIdCache.get(normalizedFeedId);
+        });
+    }
+    /**
+     * Fetches the price table object id for the current state id if not cached
+     * @returns price table object id
+     */
+    getPriceTableInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.priceTableInfo === undefined) {
+                const result = yield this.client.getDynamicFieldObject({
+                    parentId: this.pythStateId,
+                    name: {
+                        type: "vector<u8>",
+                        value: "price_info",
+                    },
+                });
+                if (!result.data || !result.data.type) {
+                    throw new Error("Price Table not found, contract may not be initialized");
+                }
+                let type = result.data.type.replace("0x2::table::Table<", "");
+                type = type.replace("::price_identifier::PriceIdentifier, 0x2::object::ID>", "");
+                this.priceTableInfo = { id: result.data.objectId, fieldType: type };
+            }
+            return this.priceTableInfo;
+        });
+    }
+    /**
+     * Checks if a message is an accumulator message or not
+     * @param msg - update message from price service
+     */
+    isAccumulatorMsg(msg) {
+        const ACCUMULATOR_MAGIC = "504e4155";
+        return msg.toString("hex").slice(0, 8) === ACCUMULATOR_MAGIC;
+    }
+    /**
+     * 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) {
+        if (!this.isAccumulatorMsg(accumulatorMessage)) {
+            throw new Error("Not an accumulator message");
+        }
+        // the first 6 bytes in the accumulator message encode the header, major, and minor bytes
+        // we ignore them, since we are only interested in the VAA bytes
+        const trailingPayloadSize = accumulatorMessage.readUint8(6);
+        const vaaSizeOffset = 7 + // header bytes (header(4) + major(1) + minor(1) + trailing payload size(1))
+            trailingPayloadSize + // trailing payload (variable number of bytes)
+            1; // proof_type (1 byte)
+        const vaaSize = accumulatorMessage.readUint16BE(vaaSizeOffset);
+        const vaaOffset = vaaSizeOffset + 2;
+        return accumulatorMessage.subarray(vaaOffset, vaaOffset + vaaSize);
+    }
+}
+exports.SuiPythClient = SuiPythClient;

package/pyth-sdk/index.d.ts

@@ -0,0 +1,4 @@
+export { SuiPriceServiceConnection } from "./SuiPriceServiceConnection";
+export { SuiPythClient } from "./client";
+export { Price, PriceFeed } from "@pythnetwork/price-service-client";
+export type { DurationInMs, HexString, PriceServiceConnectionConfig, UnixTimestamp, } from "@pythnetwork/price-service-client";

package/pyth-sdk/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceFeed = exports.Price = exports.SuiPythClient = exports.SuiPriceServiceConnection = void 0;
+var SuiPriceServiceConnection_1 = require("./SuiPriceServiceConnection");
+Object.defineProperty(exports, "SuiPriceServiceConnection", { enumerable: true, get: function () { return SuiPriceServiceConnection_1.SuiPriceServiceConnection; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "SuiPythClient", { enumerable: true, get: function () { return client_1.SuiPythClient; } });
+var price_service_client_1 = require("@pythnetwork/price-service-client");
+Object.defineProperty(exports, "Price", { enumerable: true, get: function () { return price_service_client_1.Price; } });
+Object.defineProperty(exports, "PriceFeed", { enumerable: true, get: function () { return price_service_client_1.PriceFeed; } });