@pythnetwork/pyth-sui-js 1.0.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Pyth Contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,151 @@
+# Pyth Sui JS SDK
+
+[Pyth](https://pyth.network/) provides real-time pricing data in a variety of asset classes, including cryptocurrency, equities, FX and commodities. This library allows you to use these real-time prices on the [Sui network](https://sui.io/).
+
+## Installation
+
+### npm
+
+```
+$ npm install --save @pythnetwork/pyth-sui-js
+```
+
+### Yarn
+
+```
+$ yarn add @pythnetwork/pyth-sui-js
+```
+
+## Quickstart
+
+Pyth stores prices off-chain to minimize gas fees, which allows us to offer a wider selection of products and faster update times.
+See [On-Demand Updates](https://docs.pyth.network/documentation/pythnet-price-feeds/on-demand) for more information about this approach.
+Typically, to use Pyth prices on chain,
+they must be fetched from an off-chain price service. The `SuiPriceServiceConnection` class can be used to interact with these services,
+providing a way to fetch these prices directly in your code. The following example wraps an existing RPC provider and shows how to obtain
+Pyth prices and submit them to the network:
+
+```typescript
+const connection = new SuiPriceServiceConnection(
+  "https://hermes-beta.pyth.network"
+); // See Price Service endpoints section below for other endpoints
+
+const priceIds = [
+  // You can find the ids of prices at https://pyth.network/developers/price-feed-ids#sui-testnet
+  "0xf9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b", // BTC/USD price id in testnet
+  "0xca80ba6dc32e08d06f1aa886011eed1d77c77be9eb761cc10d72b7d0a2fd57a6", // ETH/USD price id in testnet
+];
+
+// In order to use Pyth prices in your protocol you need to submit the price update data to Pyth contract in your target
+// chain. `getPriceUpdateData` creates the update data which can be submitted to your contract.
+
+const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIds);
+```
+
+## On-chain prices
+
+### **_Important Note for Integrators_**
+
+Your Sui Move module **should NOT** have a hard-coded call to `pyth::update_single_price_feed`. In other words, the Sui Pyth `pyth::update_single_price_feed` entry point should never be called by a contract, instead it should be called directly from client code (e.g. Typescript or Rust).
+
+This is because when a Sui contract is [upgraded](https://docs.sui.io/build/package-upgrades), the new address is different from the original. If your module has a hard-coded call to `pyth::update_single_price_feed` living at a fixed call-site, it may eventually get bricked due to the way Pyth upgrades are implemented. (We only allows users to interact with the most recent package version for security reasons).
+
+Therefore, you should build a [Sui programmable transaction](https://docs.sui.io/build/prog-trans-ts-sdk) that first updates the price by calling `pyth::update_single_price_feed` at the latest call-site from the client-side and then call a function in your contract that invokes `pyth::get_price` on the `PriceInfoObject` to get the recently updated price.
+You can use `SuiPythClient` to build such transactions.
+
+### Example
+
+```ts
+import { SuiPythClient } from "@pythnetwork/pyth-sui-js";
+import { TransactionBlock } from "@mysten/sui.js";
+
+const priceUpdateData = await connection.getPriceFeedsUpdateData(priceIds); // see quickstart section
+
+
+// It is either injected from browser or instantiated in backend via some private key
+const wallet: SignerWithProvider = getWallet();
+// Get the state ids of the Pyth and Wormhole contracts from
+// https://docs.pyth.network/documentation/pythnet-price-feeds/sui
+const wormholeStateId = " 0xFILL_ME";
+const pythStateId = "0xFILL_ME";
+
+const client = new SuiPythClient(wallet.provider, pythStateId, wormholeStateId);
+const tx = new TransactionBlock();
+const priceInfoObjectIds = await client.updatePriceFeeds(tx, priceFeedUpdateData, priceIds);
+
+tx.moveCall({
+    target: `YOUR_PACKAGE::YOUR_MODULE::use_pyth_for_defi`,
+    arguments: [
+        ..., // other arguments needed for your contract
+        tx.object(pythStateId),
+        tx.object(priceInfoObjectIds[0]),
+    ],
+});
+
+const txBlock = {
+    transactionBlock: tx,
+    options: {
+        showEffects: true,
+        showEvents: true,
+    },
+};
+
+const result = await wallet.signAndExecuteTransactionBlock(txBlock);
+```
+
+Now in your contract you can consume the price by calling `pyth::get_price` or other utility functions on the `PriceInfoObject`.
+
+### CLI Example
+
+[This example](./src/examples/SuiRelay.ts) shows how to update prices on an Sui network. It does the following:
+
+1. Fetches update data from the Price Service for the given price feeds.
+2. Calls the Pyth Sui contract with the update data.
+
+You can run this example with `npm run example-relay`. A full command that updates prices on Sui testnet looks like:
+
+```bash
+export SUI_KEY=YOUR_PRIV_KEY;
+npm run example-relay -- --feed-id "5a035d5440f5c163069af66062bac6c79377bf88396fa27e6067bfca8096d280" \
+--price-service "https://hermes-beta.pyth.network" \
+--full-node "https://fullnode.testnet.sui.io:443" \
+--pyth-state-id "0xd3e79c2c083b934e78b3bd58a490ec6b092561954da6e7322e1e2b3c8abfddc0" \
+--wormhole-state-id "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790"
+```
+
+## Off-chain prices
+
+Many applications additionally need to display Pyth prices off-chain, for example, in their frontend application.
+The `SuiPriceServiceConnection` provides two different ways to fetch the current Pyth price.
+The code blocks below assume that the `connection` and `priceIds` objects have been initialized as shown above.
+The first method is a single-shot query:
+
+```typescript
+// `getLatestPriceFeeds` returns a `PriceFeed` for each price id. It contains all information about a price and has
+// utility functions to get the current and exponentially-weighted moving average price, and other functionality.
+const priceFeeds = await connection.getLatestPriceFeeds(priceIds);
+// Get the price if it is not older than 60 seconds from the current time.
+console.log(priceFeeds[0].getPriceNoOlderThan(60)); // Price { conf: '1234', expo: -8, price: '12345678' }
+// Get the exponentially-weighted moving average price if it is not older than 60 seconds from the current time.
+console.log(priceFeeds[1].getEmaPriceNoOlderThan(60));
+```
+
+The object also supports a streaming websocket connection that allows you to subscribe to every new price update for a given feed.
+This method is useful if you want to show continuously updating real-time prices in your frontend:
+
+```typescript
+// Subscribe to the price feeds given by `priceId`. The callback will be invoked every time the requested feed
+// gets a price update.
+connection.subscribePriceFeedUpdates(priceIds, (priceFeed) => {
+  console.log(
+    `Received update for ${priceFeed.id}: ${priceFeed.getPriceNoOlderThan(60)}`
+  );
+});
+
+// When using the subscription, make sure to close the websocket upon termination to finish the process gracefully.
+setTimeout(() => {
+  connection.closeWebSocket();
+}, 60000);
+```
+
+## [Price Service endpoints](https://docs.pyth.network/documentation/pythnet-price-feeds/price-service#public-endpoints)

package/lib/SuiPriceServiceConnection.d.ts

@@ -0,0 +1,15 @@
+/// <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[]>;
+}
+//# sourceMappingURL=SuiPriceServiceConnection.d.ts.map

package/lib/SuiPriceServiceConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiPriceServiceConnection.d.ts","sourceRoot":"","sources":["../src/SuiPriceServiceConnection.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,sBAAsB,EACtB,SAAS,EACV,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,qBAAa,yBAA0B,SAAQ,sBAAsB;IACnE;;;;;;;OAOG;IACG,uBAAuB,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAKxE"}

package/lib/SuiPriceServiceConnection.js

@@ -0,0 +1,21 @@
+"use strict";
+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.
+     */
+    async getPriceFeedsUpdateData(priceIds) {
+        // Fetch the latest price feed update VAAs from the price service
+        const latestVaas = await this.getLatestVaas(priceIds);
+        return latestVaas.map((vaa) => buffer_1.Buffer.from(vaa, "base64"));
+    }
+}
+exports.SuiPriceServiceConnection = SuiPriceServiceConnection;

package/lib/client.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+import { JsonRpcProvider, ObjectId, TransactionBlock } from "@mysten/sui.js";
+import { HexString } from "@pythnetwork/price-service-client";
+export declare class SuiPythClient {
+    provider: JsonRpcProvider;
+    pythStateId: ObjectId;
+    wormholeStateId: ObjectId;
+    private pythPackageId;
+    private wormholePackageId;
+    private priceTableId;
+    private priceFeedObjectIdCache;
+    private baseUpdateFee;
+    constructor(provider: JsonRpcProvider, pythStateId: ObjectId, wormholeStateId: ObjectId);
+    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: ObjectId): Promise<ObjectId>;
+    /**
+     * 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<({
+        kind: "Input";
+        index: number;
+        type?: "object" | "pure" | undefined;
+        value?: any;
+    } | {
+        kind: "GasCoin";
+    } | {
+        kind: "Result";
+        index: number;
+    } | {
+        kind: "NestedResult";
+        index: number;
+        resultIndex: number;
+    })[]>;
+    /**
+     * 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<ObjectId[]>;
+    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<ObjectId | undefined>;
+    /**
+     * Fetches the price table object id for the current state id if not cached
+     * @returns price table object id
+     */
+    getPriceTableId(): Promise<ObjectId>;
+    /**
+     * 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;
+}
+//# sourceMappingURL=client.d.ts.map

package/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,eAAe,EACf,QAAQ,EAER,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAE9D,qBAAa,aAAa;IAOf,QAAQ,EAAE,eAAe;IACzB,WAAW,EAAE,QAAQ;IACrB,eAAe,EAAE,QAAQ;IARlC,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,iBAAiB,CAAuB;IAChD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,sBAAsB,CAAuC;IACrE,OAAO,CAAC,aAAa,CAAqB;gBAEjC,QAAQ,EAAE,eAAe,EACzB,WAAW,EAAE,QAAQ,EACrB,eAAe,EAAE,QAAQ;IAM5B,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAkBzC;;;;;OAKG;IACG,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuBzD;;;;OAIG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,gBAAgB;;;;;;;;;;;;;;;IAiBrD;;;;;OAKG;IACG,gBAAgB,CACpB,EAAE,EAAE,gBAAgB,EACpB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,SAAS,EAAE,GACnB,OAAO,CAAC,QAAQ,EAAE,CAAC;IAqEhB,eAAe,CAAC,EAAE,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE;IAsC7D;;OAEG;IACG,oBAAoB;IAO1B;;OAEG;IACG,gBAAgB;IAOtB;;;OAGG;IACG,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IA2B5E;;;OAGG;IACG,eAAe,IAAI,OAAO,CAAC,QAAQ,CAAC;IAmB1C;;;OAGG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM;IAK5B;;;;OAIG;IACH,qCAAqC,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM;CAe1E"}

package/lib/client.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiPythClient = void 0;
+const sui_js_1 = require("@mysten/sui.js");
+class SuiPythClient {
+    provider;
+    pythStateId;
+    wormholeStateId;
+    pythPackageId;
+    wormholePackageId;
+    priceTableId;
+    priceFeedObjectIdCache = new Map();
+    baseUpdateFee;
+    constructor(provider, pythStateId, wormholeStateId) {
+        this.provider = provider;
+        this.pythStateId = pythStateId;
+        this.wormholeStateId = wormholeStateId;
+        this.pythPackageId = undefined;
+        this.wormholePackageId = undefined;
+    }
+    async getBaseUpdateFee() {
+        if (this.baseUpdateFee === undefined) {
+            const result = await this.provider.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
+     */
+    async getPackageId(objectId) {
+        const state = await this.provider
+            .getObject({
+            id: objectId,
+            options: {
+                showContent: true,
+            },
+        })
+            .then((result) => {
+            if (result.data?.content?.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
+     */
+    async verifyVaas(vaas, tx) {
+        const wormholePackageId = await 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(Array.from(vaa)),
+                    tx.object(sui_js_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)
+     */
+    async updatePriceFeeds(tx, updates, feedIds) {
+        const wormholePackageId = await this.getWormholePackageId();
+        const packageId = await 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 = await this.verifyVaas([vaa], tx);
+            [priceUpdatesHotPotato] = tx.moveCall({
+                target: `${packageId}::pyth::create_authenticated_price_infos_using_accumulator`,
+                arguments: [
+                    tx.object(this.pythStateId),
+                    tx.pure(Array.from(updates[0])),
+                    verifiedVaas[0],
+                    tx.object(sui_js_1.SUI_CLOCK_OBJECT_ID),
+                ],
+            });
+        }
+        else if (updates.every((vaa) => !this.isAccumulatorMsg(vaa))) {
+            const verifiedVaas = await 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(sui_js_1.SUI_CLOCK_OBJECT_ID),
+                ],
+            });
+        }
+        else {
+            throw new Error("Can't mix accumulator and non-accumulator messages");
+        }
+        const priceInfoObjects = [];
+        for (const feedId of feedIds) {
+            const priceInfoObjectId = await this.getPriceFeedObjectId(feedId);
+            if (!priceInfoObjectId) {
+                throw new Error(`Price feed ${feedId} not found, please create it first`);
+            }
+            priceInfoObjects.push(priceInfoObjectId);
+            const coin = tx.splitCoins(tx.gas, [
+                tx.pure(await this.getBaseUpdateFee()),
+            ]);
+            [priceUpdatesHotPotato] = tx.moveCall({
+                target: `${packageId}::pyth::update_single_price_feed`,
+                arguments: [
+                    tx.object(this.pythStateId),
+                    priceUpdatesHotPotato,
+                    tx.object(priceInfoObjectId),
+                    coin,
+                    tx.object(sui_js_1.SUI_CLOCK_OBJECT_ID),
+                ],
+            });
+        }
+        tx.moveCall({
+            target: `${packageId}::hot_potato_vector::destroy`,
+            arguments: [priceUpdatesHotPotato],
+            typeArguments: [`${packageId}::price_info::PriceInfo`],
+        });
+        return priceInfoObjects;
+    }
+    async createPriceFeed(tx, updates) {
+        const wormholePackageId = await this.getWormholePackageId();
+        const packageId = await 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 = await this.verifyVaas([vaa], tx);
+            tx.moveCall({
+                target: `${packageId}::pyth::create_price_feeds_using_accumulator`,
+                arguments: [
+                    tx.object(this.pythStateId),
+                    tx.pure(Array.from(updates[0])),
+                    verifiedVaas[0],
+                    tx.object(sui_js_1.SUI_CLOCK_OBJECT_ID),
+                ],
+            });
+        }
+        else if (updates.every((vaa) => !this.isAccumulatorMsg(vaa))) {
+            const verifiedVaas = await 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(sui_js_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
+     */
+    async getWormholePackageId() {
+        if (!this.wormholePackageId) {
+            this.wormholePackageId = await this.getPackageId(this.wormholeStateId);
+        }
+        return this.wormholePackageId;
+    }
+    /**
+     * Get the packageId for the pyth package if not already cached
+     */
+    async getPythPackageId() {
+        if (!this.pythPackageId) {
+            this.pythPackageId = await this.getPackageId(this.pythStateId);
+        }
+        return this.pythPackageId;
+    }
+    /**
+     * Get the priceFeedObjectId for a given feedId if not already cached
+     * @param feedId
+     */
+    async getPriceFeedObjectId(feedId) {
+        const normalizedFeedId = feedId.replace("0x", "");
+        if (!this.priceFeedObjectIdCache.has(normalizedFeedId)) {
+            const tableId = await this.getPriceTableId();
+            const result = await this.provider.getDynamicFieldObject({
+                parentId: tableId,
+                name: {
+                    type: `${await this.getPythPackageId()}::price_identifier::PriceIdentifier`,
+                    value: {
+                        bytes: Array.from(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
+     */
+    async getPriceTableId() {
+        if (this.priceTableId === undefined) {
+            const result = await this.provider.getDynamicFieldObject({
+                parentId: this.pythStateId,
+                name: {
+                    type: "vector<u8>",
+                    value: "price_info",
+                },
+            });
+            if (!result.data) {
+                throw new Error("Price Table not found, contract may not be initialized");
+            }
+            this.priceTableId = result.data.objectId;
+        }
+        return this.priceTableId;
+    }
+    /**
+     * 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/lib/examples/SuiRelay.d.ts

@@ -0,0 +1,3 @@
+import { JsonRpcProvider } from "@mysten/sui.js";
+export declare function getProvider(url: string): JsonRpcProvider;
+//# sourceMappingURL=SuiRelay.d.ts.map

package/lib/examples/SuiRelay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiRelay.d.ts","sourceRoot":"","sources":["../../src/examples/SuiRelay.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,eAAe,EAGhB,MAAM,gBAAgB,CAAC;AAmCxB,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,mBAEtC"}

package/lib/examples/SuiRelay.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProvider = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const sui_js_1 = require("@mysten/sui.js");
+const client_1 = require("../client");
+const index_1 = require("../index");
+const argvPromise = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .option("feed-id", {
+    description: "Price feed ids to update without the leading 0x (e.g f9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b). Can be provided multiple times for multiple feed updates",
+    type: "array",
+    demandOption: true,
+})
+    .option("price-service", {
+    description: "Endpoint URL for the price service. e.g: https://xc-mainnet.pyth.network",
+    type: "string",
+    demandOption: true,
+})
+    .option("full-node", {
+    description: "URL of the full Sui node RPC endpoint. e.g: https://fullnode.testnet.sui.io:443",
+    type: "string",
+    demandOption: true,
+})
+    .option("pyth-state-id", {
+    description: "Pyth state object id.",
+    type: "string",
+    demandOption: true,
+})
+    .option("wormhole-state-id", {
+    description: "Wormhole state object id.",
+    type: "string",
+    demandOption: true,
+}).argv;
+function getProvider(url) {
+    return new sui_js_1.JsonRpcProvider(new sui_js_1.Connection({ fullnode: url }));
+}
+exports.getProvider = getProvider;
+async function run() {
+    if (process.env.SUI_KEY === undefined) {
+        throw new Error(`SUI_KEY environment variable should be set.`);
+    }
+    const argv = await argvPromise;
+    // Fetch the latest price feed update data from the Price Service
+    const connection = new index_1.SuiPriceServiceConnection(argv["price-service"]);
+    const feeds = argv["feed-id"];
+    const priceFeedUpdateData = await connection.getPriceFeedsUpdateData(feeds);
+    const provider = getProvider(argv["full-node"]);
+    const wormholeStateId = argv["wormhole-state-id"];
+    const pythStateId = argv["pyth-state-id"];
+    const client = new client_1.SuiPythClient(provider, pythStateId, wormholeStateId);
+    const tx = new sui_js_1.TransactionBlock();
+    await client.updatePriceFeeds(tx, priceFeedUpdateData, feeds);
+    const wallet = new sui_js_1.RawSigner(sui_js_1.Ed25519Keypair.fromSecretKey(Buffer.from(process.env.SUI_KEY, "hex")), provider);
+    const txBlock = {
+        transactionBlock: tx,
+        options: {
+            showEffects: true,
+            showEvents: true,
+        },
+    };
+    const result = await wallet.signAndExecuteTransactionBlock(txBlock);
+    console.dir(result, { depth: null });
+}
+run();

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { SuiPriceServiceConnection } from "./SuiPriceServiceConnection";
+export { SuiPythClient } from "./client";
+export { DurationInMs, HexString, Price, PriceFeed, PriceServiceConnectionConfig, UnixTimestamp, } from "@pythnetwork/price-service-client";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EACL,YAAY,EACZ,SAAS,EACT,KAAK,EACL,SAAS,EACT,4BAA4B,EAC5B,aAAa,GACd,MAAM,mCAAmC,CAAC"}

package/lib/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; } });

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@pythnetwork/pyth-sui-js",
+  "version": "1.0.0",
+  "description": "Pyth Network Sui Utilities",
+  "homepage": "https://pyth.network",
+  "author": {
+    "name": "Pyth Data Association"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyth-network/pyth-crosschain",
+    "directory": "target_chains/sui/sdk/js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest --passWithNoTests",
+    "build": "tsc",
+    "example-relay": "npm run build && node lib/examples/SuiRelay.js",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build && npm test && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src"
+  },
+  "keywords": [
+    "pyth",
+    "oracle",
+    "sui"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@truffle/hdwallet-provider": "^2.1.5",
+    "@types/ethereum-protocol": "^1.0.2",
+    "@types/jest": "^29.4.0",
+    "@types/node": "^18.11.18",
+    "@types/web3-provider-engine": "^14.0.1",
+    "@types/yargs": "^17.0.20",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
+    "eslint": "^8.14.0",
+    "jest": "^29.4.1",
+    "prettier": "^2.6.2",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.6.3",
+    "web3": "^1.8.2",
+    "yargs": "^17.0.20"
+  },
+  "dependencies": {
+    "@mysten/sui.js": "^0.32.2",
+    "@pythnetwork/price-service-client": "*",
+    "buffer": "^6.0.3"
+  },
+  "gitHead": "55129e5b891b0ce0271dbee69a8b4b7512a222d1"
+}