@pythnetwork/pyth-lazer-iota-js 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 Pyth Data Association.
+
+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

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# Pyth Lazer IOTA JS SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This package provides utilities to create an IOTA programmable transaction that
+parses and verifies a Pyth Lazer price update on-chain.
+
+## Build
+
+From the repository root:
+
+```sh
+pnpm turbo build -F @pythnetwork/pyth-lazer-iota-js
+```
+
+## Quickstart
+
+A runnable example is provided at `src/examples/fetch-and-verify.ts`. It:
+
+- connects to Lazer via `@pythnetwork/pyth-lazer-sdk`,
+- fetches a single `leEcdsa` payload,
+- composes an IOTA transaction calling `parse_and_verify_le_ecdsa_update`.
+
+### Run the example
+
+```sh
+# Your IOTA private key in Bech32 format
+# export IOTA_KEY=
+
+# Lazer contract state ID
+# STATE_ID=
+
+# Your Lazer API token
+# LAZER_TOKEN=
+
+IOTA_FULLNODE_URL="https://api.testnet.iota.cafe/"
+
+pnpm run example:fetch-and-verify \
+  --base-url "$IOTA_FULLNODE_URL" \
+  --state-id "$STATE_ID" \
+  --lazer-token "$LAZER_TOKEN"
+```
+
+The script's core logic is summarized below:
+
+```ts
+import { Buffer } from "node:buffer";
+import { IotaClient } from "@iota/iota-sdk/client";
+import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519";
+import { Transaction } from "@iota/iota-sdk/transactions";
+import { PythLazerClient } from "@pythnetwork/pyth-lazer-sdk";
+import { addParseAndVerifyLeEcdsaUpdateCall } from "@pythnetwork/pyth-lazer-iota-js";
+
+// 1. Fetch the price update from Pyth Lazer in "leEcdsa" format:
+const lazer = await PythLazerClient.create({ token: LAZER_TOKEN });
+const latestPrice = await lazer.getLatestPrice({
+  channel: "fixed_rate@200ms",
+  formats: ["leEcdsa"],
+  jsonBinaryEncoding: "hex",
+  priceFeedIds: [1],
+  properties: ["price", "bestBidPrice", "bestAskPrice", "exponent"],
+});
+const update = Buffer.from(latestPrice.leEcdsa?.data ?? "", "hex");
+
+// 2. Create a new IOTA transaction:
+const signer = Ed25519Keypair.fromSecretKey(IOTA_KEY);
+const client = new IotaClient({ url: IOTA_FULLNODE_URL });
+const tx = new Transaction();
+
+// 3. Add the parse and verify call:
+const verifiedUpdate = await addParseAndVerifyLeEcdsaUpdateCall({
+  client,
+  stateObjectId: STATE_ID,
+  tx,
+  update,
+});
+
+// 4. Consume `verifiedUpdate` in your own contract with additional calls...
+
+// 5. Sign and execute the transaction:
+const result = await client.signAndExecuteTransaction({
+  signer,
+  transaction: tx,
+});
+```
+
+## References
+
+- Pyth Lazer IOTA contract: `lazer/contracts/iota/`
+- Lazer JS SDK: https://www.npmjs.com/package/@pythnetwork/pyth-lazer-sdk
+- IOTA TypeScript SDK: https://www.npmjs.com/package/@iota/iota-sdk

package/dist/cjs/index.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "addParseAndVerifyLeEcdsaUpdateCall", {
+    enumerable: true,
+    get: function() {
+        return addParseAndVerifyLeEcdsaUpdateCall;
+    }
+});
+async function addParseAndVerifyLeEcdsaUpdateCall(opts) {
+    const { client, tx, stateObjectId, update } = opts;
+    const packageId = await getLatestPackageId(client, stateObjectId);
+    return tx.moveCall({
+        arguments: [
+            tx.object(stateObjectId),
+            tx.object.clock(),
+            tx.pure.vector("u8", update)
+        ],
+        target: `${packageId}::pyth_lazer::parse_and_verify_le_ecdsa_update`
+    });
+}
+async function getLatestPackageId(client, stateObjectId) {
+    const { data: stateObject, error } = await client.getObject({
+        id: stateObjectId,
+        options: {
+            showContent: true
+        }
+    });
+    if (!stateObject?.content || error) {
+        throw new Error(`Failed to get IOTA Lazer State: ${error?.code ?? "undefined"}`);
+    }
+    if (stateObject.content.dataType !== "moveObject") {
+        throw new Error(`IOTA Lazer State must be an object, got: ${stateObject.content.dataType}`);
+    }
+    const { fields } = stateObject.content;
+    if (!hasProperty(fields, "upgrade_cap")) {
+        throw new Error("Missing 'upgrade_cap' in IOTA Lazer State");
+    }
+    const upgradeCap = fields.upgrade_cap;
+    if (!hasProperty(upgradeCap, "fields") || !hasProperty(upgradeCap.fields, "package") || typeof upgradeCap.fields.package !== "string") {
+        throw new Error("Could not find 'package' string in IOTA Lazer UpgradeCap");
+    }
+    return upgradeCap.fields.package;
+}
+function hasProperty(value, name) {
+    return typeof value === "object" && value !== null && name in value;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+import type { IotaClient } from "@iota/iota-sdk/client";
+import type { Transaction } from "@iota/iota-sdk/transactions";
+export declare function addParseAndVerifyLeEcdsaUpdateCall(opts: {
+    client: IotaClient;
+    tx: Transaction;
+    stateObjectId: string;
+    update: Uint8Array;
+}): Promise<import("@iota/iota-sdk/transactions").TransactionResult>;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+import type { IotaClient } from "@iota/iota-sdk/client";
+import type { Transaction } from "@iota/iota-sdk/transactions";
+export declare function addParseAndVerifyLeEcdsaUpdateCall(opts: {
+    client: IotaClient;
+    tx: Transaction;
+    stateObjectId: string;
+    update: Uint8Array;
+}): Promise<import("@iota/iota-sdk/transactions").TransactionResult>;

package/dist/esm/index.mjs

@@ -0,0 +1,38 @@
+export async function addParseAndVerifyLeEcdsaUpdateCall(opts) {
+    const { client, tx, stateObjectId, update } = opts;
+    const packageId = await getLatestPackageId(client, stateObjectId);
+    return tx.moveCall({
+        arguments: [
+            tx.object(stateObjectId),
+            tx.object.clock(),
+            tx.pure.vector("u8", update)
+        ],
+        target: `${packageId}::pyth_lazer::parse_and_verify_le_ecdsa_update`
+    });
+}
+async function getLatestPackageId(client, stateObjectId) {
+    const { data: stateObject, error } = await client.getObject({
+        id: stateObjectId,
+        options: {
+            showContent: true
+        }
+    });
+    if (!stateObject?.content || error) {
+        throw new Error(`Failed to get IOTA Lazer State: ${error?.code ?? "undefined"}`);
+    }
+    if (stateObject.content.dataType !== "moveObject") {
+        throw new Error(`IOTA Lazer State must be an object, got: ${stateObject.content.dataType}`);
+    }
+    const { fields } = stateObject.content;
+    if (!hasProperty(fields, "upgrade_cap")) {
+        throw new Error("Missing 'upgrade_cap' in IOTA Lazer State");
+    }
+    const upgradeCap = fields.upgrade_cap;
+    if (!hasProperty(upgradeCap, "fields") || !hasProperty(upgradeCap.fields, "package") || typeof upgradeCap.fields.package !== "string") {
+        throw new Error("Could not find 'package' string in IOTA Lazer UpgradeCap");
+    }
+    return upgradeCap.fields.package;
+}
+function hasProperty(value, name) {
+    return typeof value === "object" && value !== null && name in value;
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/package.json

@@ -1,6 +1,60 @@
 {
+  "dependencies": {
+    "@iota/iota-sdk": "^1.11.0"
+  },
+  "description": "TypeScript SDK for the Pyth Lazer IOTA contract",
+  "devDependencies": {
+    "@cprussin/tsconfig": "^4.0.2",
+    "@pythnetwork/jest-config": "",
+    "@pythnetwork/pyth-lazer-sdk": "^5.2.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.14.0",
+    "@types/yargs": "^17.0.33",
+    "jest": "^29.7.0",
+    "tsx": "4.20.6",
+    "yargs": "^18.0.0"
+  },
+  "engines": {
+    "node": "^24.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./dist/esm/index.mjs",
+        "types": "./dist/esm/index.d.ts"
+      },
+      "require": {
+        "default": "./dist/cjs/index.cjs",
+        "types": "./dist/cjs/index.d.ts"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.mjs",
   "name": "@pythnetwork/pyth-lazer-iota-js",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "lazer/contracts/iota/sdk/js",
+    "type": "git",
+    "url": "https://github.com/pyth-network/pyth-crosschain"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/cjs/index.d.ts",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "ts-duality --copyOtherFiles",
+    "clean": "rm -rf ./dist",
+    "example:fetch-and-verify": "tsx src/examples/fetch-and-verify.ts",
+    "test:types": "tsc",
+    "test:unit": "test-unit"
+  }
 }