feat(contract_manager): more support for starknet contract (#1716)

* feat(contract_manager): more support for starknet contract

* chore(contract_manager): update pyth-starknet-js

Author: Riateche

contract_manager/package.json

@@ -34,6 +34,7 @@
     "@pythnetwork/price-service-client": "workspace:*",
     "@pythnetwork/pyth-fuel-js": "workspace:*",
     "@pythnetwork/pyth-sdk-solidity": "workspace:^",
+    "@pythnetwork/pyth-starknet-js": "^0.2.0",
     "@pythnetwork/pyth-sui-js": "workspace:*",
     "@pythnetwork/solana-utils": "workspace:^",
     "@pythnetwork/xc-admin-common": "workspace:*",
@@ -45,7 +46,7 @@
     "extract-files": "^13.0.0",
     "fuels": "^0.89.2",
     "ramda": "^0.30.1",
-    "starknet": "^5.24.3",
+    "starknet": "^6.9.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.3.3",
     "web3": "^1.8.2",
@@ -54,8 +55,8 @@
   },
   "devDependencies": {
     "@types/web3": "^1.2.2",
+    "eslint": "^8.0.0",
     "prettier": "^2.6.2",
-    "typedoc": "^0.25.7",
-    "eslint": "^8.0.0"
+    "typedoc": "^0.25.7"
   }
 }

contract_manager/src/contracts/starknet.ts

@@ -1,13 +1,15 @@
 import { DataSource } from "@pythnetwork/xc-admin-common";
 import {
   KeyValueConfig,
+  Price,
   PriceFeed,
   PriceFeedContract,
   PrivateKey,
   TxResult,
 } from "../base";
 import { Chain, StarknetChain } from "../chains";
-import { Contract } from "starknet";
+import { Account, Contract, shortString } from "starknet";
+import { ByteBuffer } from "@pythnetwork/pyth-starknet-js";
 
 export class StarknetPriceFeedContract extends PriceFeedContract {
   static type = "StarknetPriceFeedContract";
@@ -65,29 +67,146 @@ export class StarknetPriceFeedContract extends PriceFeedContract {
     });
   }
 
-  getBaseUpdateFee(): Promise<{ amount: string; denom?: string | undefined }> {
-    throw new Error("Method not implemented.");
+  async getBaseUpdateFee(): Promise<{
+    amount: string;
+    denom?: string | undefined;
+  }> {
+    const tokens = await this.getFeeTokenAddresses();
+    return await this.getBaseUpdateFeeInToken(tokens[0]);
   }
-  getLastExecutedGovernanceSequence(): Promise<number> {
-    throw new Error("Method not implemented.");
+
+  /**
+   * Returns the list of accepted fee tokens.
+   * @returns hex encoded token addresses without 0x prefix
+   */
+  async getFeeTokenAddresses(): Promise<string[]> {
+    const contract = await this.getContractClient();
+    const tokens: bigint[] = await contract.fee_token_addresses();
+    return tokens.map((t) => t.toString(16));
   }
-  getPriceFeed(feedId: string): Promise<PriceFeed | undefined> {
-    throw new Error("Method not implemented.");
+
+  /**
+   * Returns the single update fee and symbol of the specified token.
+   * @param token hex encoded token address without 0x prefix
+   */
+  async getBaseUpdateFeeInToken(
+    token: string
+  ): Promise<{ amount: string; denom?: string | undefined }> {
+    token = "0x" + token;
+    const provider = this.chain.getProvider();
+    const contract = await this.getContractClient();
+    const fee: bigint = await contract.get_single_update_fee(token);
+
+    const tokenClassData = await provider.getClassAt(token);
+    const tokenContract = new Contract(tokenClassData.abi, token, provider);
+    const denom = shortString.decodeShortString(await tokenContract.symbol());
+    return { amount: fee.toString(), denom };
   }
-  executeUpdatePriceFeed(
+
+  async getLastExecutedGovernanceSequence(): Promise<number> {
+    const contract = await this.getContractClient();
+    return Number(await contract.last_executed_governance_sequence());
+  }
+
+  async getPriceFeed(feedId: string): Promise<PriceFeed | undefined> {
+    const contract = await this.getContractClient();
+    const result = await contract.query_price_feed_unsafe("0x" + feedId);
+    console.log(result);
+    if (result.Ok !== undefined) {
+      return {
+        price: convertPrice(result.Ok.price),
+        emaPrice: convertPrice(result.Ok.ema_price),
+      };
+    } else {
+      throw new Error(JSON.stringify(result.Err));
+    }
+  }
+
+  async executeUpdatePriceFeed(
     senderPrivateKey: PrivateKey,
     vaas: Buffer[]
   ): Promise<TxResult> {
-    throw new Error("Method not implemented.");
+    // We need the account address to send transactions.
+    throw new Error("Use executeUpdatePriceFeedWithAddress instead");
   }
+
+  /**
+   * Executes the update instructions contained in the VAAs using the sender credentials
+   * @param senderPrivateKey private key of the sender in hex format without 0x prefix
+   * @param senderAddress address of the sender's account in hex format without 0x prefix
+   * @param vaa VAA containing price update messages to execute
+   */
+  async executeUpdatePriceFeedWithAddress(
+    senderPrivateKey: PrivateKey,
+    senderAddress: string,
+    vaa: Buffer
+  ): Promise<TxResult> {
+    const provider = this.chain.getProvider();
+    const contract = await this.getContractClient();
+    const account = new Account(
+      provider,
+      "0x" + senderAddress,
+      "0x" + senderPrivateKey
+    );
+    contract.connect(account);
+
+    const feeToken = "0x" + (await this.getFeeTokenAddresses())[0];
+    const tokenClassData = await provider.getClassAt(feeToken);
+    const tokenContract = new Contract(tokenClassData.abi, feeToken, provider);
+    tokenContract.connect(account);
+
+    const updateData = ByteBuffer.fromBuffer(vaa);
+    const feeAmount = await contract.get_update_fee(updateData, feeToken);
+    const feeTx = await tokenContract.approve(this.address, feeAmount);
+    await provider.waitForTransaction(feeTx.transaction_hash);
+
+    const tx = await contract.update_price_feeds(updateData);
+    const info = await provider.waitForTransaction(tx.transaction_hash);
+    return { id: tx.transaction_hash, info };
+  }
+
   executeGovernanceInstruction(
     senderPrivateKey: PrivateKey,
     vaa: Buffer
   ): Promise<TxResult> {
-    throw new Error("Method not implemented.");
+    // We need the account address to send transactions.
+    throw new Error("Use executeGovernanceInstructionWithAddress instead");
+  }
+
+  /**
+   * Executes the governance instruction contained in the VAA using the sender credentials
+   * @param senderPrivateKey private key of the sender in hex format without 0x prefix
+   * @param senderAddress address of the sender's account in hex format without 0x prefix
+   * @param vaa the VAA to execute
+   */
+  async executeGovernanceInstructionWithAddress(
+    senderPrivateKey: PrivateKey,
+    senderAddress: string,
+    vaa: Buffer
+  ): Promise<TxResult> {
+    const provider = this.chain.getProvider();
+    const contract = await this.getContractClient();
+    const account = new Account(
+      provider,
+      "0x" + senderAddress,
+      "0x" + senderPrivateKey
+    );
+    contract.connect(account);
+
+    const updateData = ByteBuffer.fromBuffer(vaa);
+    const tx = await contract.execute_governance_instruction(updateData);
+    const info = await provider.waitForTransaction(tx.transaction_hash);
+    return { id: tx.transaction_hash, info };
   }
-  getGovernanceDataSource(): Promise<DataSource> {
-    throw new Error("Method not implemented.");
+
+  async getGovernanceDataSource(): Promise<DataSource> {
+    const contract = await this.getContractClient();
+    const source: { emitter_chain_id: bigint; emitter_address: bigint } =
+      await contract.governance_data_source();
+    return {
+      emitterChain: Number(source.emitter_chain_id),
+      emitterAddress: source.emitter_address.toString(16),
+    };
   }
 
   getId(): string {
@@ -98,3 +217,17 @@ export class StarknetPriceFeedContract extends PriceFeedContract {
     return StarknetPriceFeedContract.type;
   }
 }
+
+function convertPrice(obj: {
+  price: bigint;
+  conf: bigint;
+  expo: bigint;
+  publish_time: bigint;
+}): Price {
+  return {
+    price: obj.price.toString(),
+    conf: obj.conf.toString(),
+    expo: obj.expo.toString(),
+    publishTime: obj.publish_time.toString(),
+  };
+}