@ledgerhq/coin-sui 0.11.0 → 0.12.0-nightly.0

package/src/network/sdk.ts

@@ -8,11 +8,13 @@ import {
   SuiClient,
   SuiHTTPTransport,
   SuiTransactionBlockResponse,
+  SuiTransaction,
+  SuiTransactionBlockKind,
+  TransactionEffects,
   SuiTransactionBlockResponseOptions,
   DelegatedStake,
   StakeObject,
   TransactionBlockData,
-  TransactionEffects,
 } from "@mysten/sui/client";
 import { Transaction } from "@mysten/sui/transactions";
 import { BigNumber } from "bignumber.js";
@@ -31,15 +33,16 @@ import uniqBy from "lodash/unionBy";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { log } from "@ledgerhq/logs";
 import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
-import type { Transaction as TransactionType } from "../types";
-import type { CreateExtrinsicArg } from "../logic/craftTransaction";
+import type { Transaction as TransactionType, SuiValidator, CreateExtrinsicArg } from "../types";
 import { ensureAddressFormat } from "../utils";
 import coinConfig from "../config";
 import { getEnv } from "@ledgerhq/live-env";
-
-type AsyncApiFunction<T> = (api: SuiClient) => Promise<T>;
+import { SUI_SYSTEM_STATE_OBJECT_ID } from "@mysten/sui/utils";
+import { getCurrentSuiPreloadData } from "../bridge/preload";
+import { ONE_SUI } from "../constants";
 
 const apiMap: Record<string, SuiClient> = {};
+type AsyncApiFunction<T> = (api: SuiClient) => Promise<T>;
 
 export const TRANSACTIONS_LIMIT_PER_QUERY = 50;
 export const TRANSACTIONS_LIMIT = 300;
@@ -58,10 +61,12 @@ type GenericInput<T> = T extends (...args: infer K) => unknown ? K : never;
 type Inputs = GenericInput<typeof fetch>;
 
 const fetcher = (url: Inputs[0], options: Inputs[1], retry = 3): Promise<Response> => {
+  const version = getEnv("LEDGER_CLIENT_VERSION") || "";
+  const isCI = version.includes("ll-ci") || version === "";
   if (options) {
     options.headers = {
       ...options.headers,
-      "X-Ledger-Client-Version": getEnv("LEDGER_CLIENT_VERSION"),
+      "X-Ledger-Client-Version": isCI ? "lld/2.124.0-dev" : version, // for integration cli tests
     };
   }
   if (retry === 1) return fetch(url, options);
@@ -96,6 +101,33 @@ export const getAllBalancesCached = makeLRUCache(
   (owner: string) => owner,
   minutes(1),
 );
+function isStaking(block?: SuiTransactionBlockKind): block is {
+  inputs: SuiCallArg[];
+  kind: "ProgrammableTransaction";
+  transactions: SuiTransaction[];
+} {
+  if (!block) return false;
+  if (block.kind === "ProgrammableTransaction") {
+    const move = block.transactions.find(item => "MoveCall" in item) as any;
+    return move?.MoveCall.function === "request_add_stake";
+  }
+  return false;
+}
+
+function isUnstaking(block?: SuiTransactionBlockKind): block is {
+  inputs: SuiCallArg[];
+  kind: "ProgrammableTransaction";
+  transactions: SuiTransaction[];
+} {
+  if (!block) return false;
+  if (block.kind === "ProgrammableTransaction") {
+    const move = block.transactions.find(
+      item => "MoveCall" in item && item["MoveCall"].function === "request_withdraw_stake",
+    ) as any;
+    return Boolean(move);
+  }
+  return false;
+}
 
 /**
  * Get account balance (native and tokens)
@@ -119,8 +151,20 @@ export function isSender(addr: string, transaction?: TransactionBlockData): bool
 /**
  * Map transaction to an Operation Type
  */
-export function getOperationType(addr: string, transaction?: TransactionBlockData): OperationType {
-  return isSender(addr, transaction) ? "OUT" : "IN";
+export function getOperationType(
+  addr: string,
+  { transaction }: SuiTransactionBlockResponse,
+): OperationType {
+  if (!isSender(addr, transaction?.data)) {
+    return "IN";
+  }
+  if (isStaking(transaction?.data.transaction)) {
+    return "DELEGATE";
+  }
+  if (isUnstaking(transaction?.data.transaction)) {
+    return "UNDELEGATE";
+  }
+  return "OUT";
 }
 
 /**
@@ -134,14 +178,17 @@ export const getOperationSenders = (transaction?: TransactionBlockData): string[
  * Extract recipients from transaction
  */
 export const getOperationRecipients = (transaction?: TransactionBlockData): string[] => {
-  if (transaction?.transaction.kind === "ProgrammableTransaction") {
-    if (!transaction?.transaction?.inputs) return [];
+  if (!transaction) return [];
+
+  if (transaction.transaction.kind === "ProgrammableTransaction") {
+    if (!transaction.transaction.inputs) return [];
     const recipients: string[] = [];
     transaction.transaction.inputs.forEach((input: SuiCallArg) => {
       if ("valueType" in input && input.valueType === "address") {
         recipients.push(String(input.value));
       }
     });
+    if (isUnstaking(transaction.transaction) || isStaking(transaction.transaction)) return [];
     return recipients;
   }
   return [];
@@ -157,6 +204,14 @@ export const getOperationAmount = (
 ): BigNumber => {
   let amount = new BigNumber(0);
   if (!transaction?.balanceChanges) return amount;
+  if (
+    isStaking(transaction.transaction?.data.transaction) ||
+    isUnstaking(transaction.transaction?.data.transaction)
+  ) {
+    const balanceChange = transaction.balanceChanges[0];
+    return amount.minus(balanceChange?.amount || 0);
+  }
+
   for (const balanceChange of transaction.balanceChanges) {
     if (
       typeof balanceChange.owner !== "string" &&
@@ -186,6 +241,39 @@ export const getOperationFee = (transaction: SuiTransactionBlockResponse): BigNu
   return computationCost.plus(storageCost).minus(storageRebate);
 };
 
+export const getOperationExtra = (digest: string): Promise<Record<string, string>> =>
+  withApi(async api => {
+    const response = await api.getTransactionBlock({
+      digest,
+      options: {
+        showInput: true,
+        showBalanceChanges: true,
+        showEffects: true,
+        showEvents: true,
+      },
+    });
+    const tx = response.transaction?.data?.transaction;
+    if (isStaking(tx)) {
+      const inputs = tx.inputs;
+      const pure = inputs.filter(x => x.type === "pure") as { valueType: string; value: string }[];
+      const amount = pure.find(x => x.valueType === "u64")?.value as string;
+      const address = pure.find(x => x.valueType === "address")?.value as string;
+      const name = getCurrentSuiPreloadData().validators.find(x => x.suiAddress === address)?.name;
+      return { amount, address, name: name || "" };
+    }
+
+    if (isUnstaking(response.transaction?.data?.transaction)) {
+      const { principal_amount: amount, validator_address: address } = response.events?.find(
+        e => e.type === "0x3::validator::UnstakingRequestEvent",
+      )?.parsedJson as Record<string, string>;
+      const name = getCurrentSuiPreloadData().validators.find(x => x.suiAddress === address)?.name;
+
+      return { amount, address, name: name || "" };
+    }
+
+    return {};
+  });
+
 /**
  * Extract date from transaction
  */
@@ -193,6 +281,11 @@ export const getOperationDate = (transaction: SuiTransactionBlockResponse): Date
   return new Date(parseInt(transaction.timestampMs!));
 };
 
+export const getStakesRaw = (owner: string) =>
+  withApi(async api => {
+    return api.getStakes({ owner });
+  });
+
 /**
  * Extract operation coin type from transaction
  */
@@ -217,7 +310,7 @@ export function transactionToOperation(
   address: string,
   transaction: SuiTransactionBlockResponse,
 ): Operation {
-  const type = getOperationType(address, transaction.transaction?.data);
+  const type = getOperationType(address, transaction);
 
   const coinType = getOperationCoinType(transaction);
   const hash = transaction.digest;
@@ -232,7 +325,7 @@ export function transactionToOperation(
       coinType,
     },
     fee: getOperationFee(transaction),
-    hasFailed: transaction.effects?.status.status != "success",
+    hasFailed: transaction.effects?.status.status !== "success",
     hash,
     recipients: getOperationRecipients(transaction.transaction?.data),
     senders: getOperationSenders(transaction.transaction?.data),
@@ -242,7 +335,7 @@ export function transactionToOperation(
 }
 
 export function transactionToOp(address: string, transaction: SuiTransactionBlockResponse): Op {
-  const type = getOperationType(address, transaction.transaction?.data);
+  const type = getOperationType(address, transaction);
   const coinType = getOperationCoinType(transaction);
   const hash = transaction.digest;
   return {
@@ -278,7 +371,7 @@ export function toBlockInfo(checkpoint: Checkpoint): BlockInfo {
     time: new Date(parseInt(checkpoint.timestampMs)),
   };
 
-  if (typeof checkpoint.previousDigest == "string")
+  if (typeof checkpoint.previousDigest === "string")
     return {
       ...info,
       parent: {
@@ -303,7 +396,7 @@ export function toBlockInfo(checkpoint: Checkpoint): BlockInfo {
 export function toBlockTransaction(transaction: SuiTransactionBlockResponse): BlockTransaction {
   return {
     hash: transaction.digest,
-    failed: transaction.effects?.status.status != "success",
+    failed: transaction.effects?.status.status !== "success",
     operations: transaction.balanceChanges?.flatMap(toBlockOperation) || [],
     fees: BigInt(getOperationFee(transaction).toString()),
     feesPayer: transaction.transaction?.data.sender || "",
@@ -316,7 +409,7 @@ export function toBlockTransaction(transaction: SuiTransactionBlockResponse): Bl
  * @param change balance change
  */
 export function toBlockOperation(change: BalanceChange): BlockOperation[] {
-  if (typeof change.owner == "string" || !("AddressOwner" in change.owner)) return [];
+  if (typeof change.owner === "string" || !("AddressOwner" in change.owner)) return [];
   return [
     {
       type: "transfer",
@@ -537,27 +630,65 @@ export const createTransaction = async (address: string, transaction: CreateExtr
   withApi(async api => {
     const tx = new Transaction();
     tx.setSender(ensureAddressFormat(address));
+    const { mode, amount } = transaction;
+    switch (mode) {
+      case "delegate": {
+        const coins = tx.splitCoins(tx.gas, [amount.toNumber()]);
+        tx.moveCall({
+          target: "0x3::sui_system::request_add_stake",
+          arguments: [
+            tx.object(SUI_SYSTEM_STATE_OBJECT_ID),
+            coins,
+            tx.pure.address(transaction.recipient),
+          ],
+        });
+
+        tx.setGasBudgetIfNotSet(ONE_SUI / 10);
+        break;
+      }
+      case "undelegate": {
+        if (transaction.useAllAmount) {
+          tx.moveCall({
+            target: "0x3::sui_system::request_withdraw_stake",
+            arguments: [tx.object(SUI_SYSTEM_STATE_OBJECT_ID), tx.object(transaction.stakedSuiId!)],
+          });
+        } else {
+          const res = tx.moveCall({
+            target: "0x3::staking_pool::split",
+            arguments: [tx.object(transaction.stakedSuiId!), tx.pure.u64(amount.toString())],
+          });
+          tx.moveCall({
+            target: "0x3::sui_system::request_withdraw_stake",
+            arguments: [tx.object(SUI_SYSTEM_STATE_OBJECT_ID), res],
+          });
+        }
+
+        tx.setGasBudgetIfNotSet(ONE_SUI / 10);
+        break;
+      }
+      default: {
+        if (transaction.coinType !== DEFAULT_COIN_TYPE) {
+          const requiredAmount = transaction.amount.toNumber();
 
-    if (transaction.coinType !== DEFAULT_COIN_TYPE) {
-      const requiredAmount = transaction.amount.toNumber();
+          const coins = await getCoinsForAmount(api, address, transaction.coinType, requiredAmount);
 
-      const coins = await getCoinsForAmount(api, address, transaction.coinType, requiredAmount);
+          if (coins.length === 0) {
+            throw new Error(`No coins found for type ${transaction.coinType}`);
+          }
 
-      if (coins.length === 0) {
-        throw new Error(`No coins found for type ${transaction.coinType}`);
-      }
+          const coinObjects = coins.map(coin => tx.object(coin.coinObjectId));
 
-      const coinObjects = coins.map(coin => tx.object(coin.coinObjectId));
+          if (coinObjects.length > 1) {
+            tx.mergeCoins(coinObjects[0], coinObjects.slice(1));
+          }
 
-      if (coinObjects.length > 1) {
-        tx.mergeCoins(coinObjects[0], coinObjects.slice(1));
+          const [coin] = tx.splitCoins(coinObjects[0], [transaction.amount.toNumber()]);
+          tx.transferObjects([coin], transaction.recipient);
+        } else {
+          const [coin] = tx.splitCoins(tx.gas, [transaction.amount.toNumber()]);
+          tx.transferObjects([coin], transaction.recipient);
+        }
       }
-
-      const [coin] = tx.splitCoins(coinObjects[0], [transaction.amount.toNumber()]);
-      tx.transferObjects([coin], transaction.recipient);
-    } else {
-      const [coin] = tx.splitCoins(tx.gas, [transaction.amount.toNumber()]);
-      tx.transferObjects([coin], transaction.recipient);
     }
 
     return tx.build({ client: api });
@@ -726,3 +857,20 @@ export const toStakeAmounts = (stake: StakeObject): { deposited: bigint; rewarde
       return { deposited: BigInt(stake.principal), rewarded: 0n }; // note: we lose reward information in unstaked state here
   }
 };
+
+export const getValidators = (): Promise<SuiValidator[]> =>
+  withApi(async api => {
+    const [{ activeValidators }, { apys }] = await Promise.all([
+      api.getLatestSuiSystemState(),
+      api.getValidatorsApy(),
+    ]);
+    const hash = apys.reduce(
+      (acc, item) => {
+        acc[item.address] = item.apy;
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
+
+    return activeValidators.map(item => ({ ...item, apy: hash[item.suiAddress] }));
+  });

package/src/types/bridge.ts

@@ -8,18 +8,29 @@ import type {
   OperationRaw,
 } from "@ledgerhq/types-live";
 import type { Account, AccountRaw } from "@ledgerhq/types-live";
+import { DelegatedStake, StakeObject, SuiValidatorSummary } from "@mysten/sui/client";
+
+export type MappedStake = StakeObject & {
+  rank: number;
+  validator: SuiValidator;
+  stakedSuiId: string;
+  formattedAmount: string;
+};
 
 /**
  * Sui account resources
  */
-export type SuiResources = object;
+export type SuiResources = {
+  stakes?: DelegatedStake[];
+  cachedOps?: Record<string, Record<string, string>>;
+};
 
 /**
  * Sui account resources from raw JSON
  */
 export type SuiResourcesRaw = object;
 
-export type SuiTransactionMode = "send" | "token.send";
+export type SuiTransactionMode = "send" | "token.send" | "delegate" | "undelegate";
 
 /**
  * Sui transaction
@@ -29,12 +40,22 @@ export type Transaction = TransactionCommon & {
   family: "sui";
   amount: BigNumber | null;
   fees?: BigNumber | null;
-  errors: Record<string, Error>;
+  errors?: Record<string, Error>;
   skipVerify?: boolean;
   coinType: string;
+  stakedSuiId?: string;
   // add here all transaction-specific fields when implement other modes than "send"
 };
 
+export type CreateExtrinsicArg = {
+  amount: BigNumber;
+  coinType: string;
+  mode: SuiTransactionMode;
+  recipient: string;
+  useAllAmount?: boolean;
+  stakedSuiId?: string;
+};
+
 /**
  * Sui transaction from a raw JSON
  */
@@ -46,12 +67,17 @@ export type TransactionRaw = TransactionCommonRaw & {
   // also the transaction fields as raw JSON data
 };
 
+/**
+ * Sui validator metadata
+ */
+export type SuiValidator = SuiValidatorSummary & { apy: number };
+
 /**
  * Sui currency data that will be preloaded.
  * You can for instance add a list of validators for Proof-of-Stake blockchains,
  * or any volatile data that could not be set as constants in the code (staking progress, fee estimation variables, etc.)
  */
-export type SuiPreloadData = object;
+export type SuiPreloadData = { validators: SuiValidator[] };
 
 export type SuiAccount = Account & {
   // On some blockchain, an account can have resources (gained, delegated, ...)
@@ -84,14 +110,14 @@ export type SuiSignedOperation = {
 };
 
 export type TransferCommand = {
-  kind: "send";
+  kind: SuiTransactionMode;
   sender: string;
   recipient: string;
   amount: number;
 };
 
 export type TokenTransferCommand = {
-  kind: "token.send";
+  kind: string;
   sender: string;
   recipient: string;
   amount: number;