@ledgerhq/coin-sui 0.2.0-next.0

package/src/network/sdk.ts

@@ -0,0 +1,262 @@
+import {
+  PaginatedTransactionResponse,
+  QueryTransactionBlocksParams,
+  SuiClient,
+  ExecuteTransactionBlockParams,
+  TransactionEffects,
+} from "@mysten/sui/client";
+import { TransactionBlockData, SuiTransactionBlockResponse, SuiCallArg } from "@mysten/sui/client";
+import { Transaction } from "@mysten/sui/transactions";
+import { BigNumber } from "bignumber.js";
+import type { Operation, OperationType } from "@ledgerhq/types-live";
+
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+
+import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
+import { getEnv } from "@ledgerhq/live-env";
+
+import type { Transaction as TransactionType } from "../types";
+import type { CreateExtrinsicArg } from "../logic/craftTransaction";
+import { ensureAddressFormat } from "../utils";
+
+type AsyncApiFunction<T> = (api: SuiClient) => Promise<T>;
+
+const rpcUrl = getEnv("API_SUI_NODE_PROXY");
+
+let api: SuiClient | null = null;
+
+const TRANSACTIONS_REQUEST_LIMIT = 100;
+
+const BLOCK_HEIGHT = 5; // sui has no block height metainfo, we use it simulate proper icon statuses in apps
+
+/**
+ * Connects to Sui Api
+ */
+async function withApi<T>(execute: AsyncApiFunction<T>) {
+  if (!api) {
+    api = new SuiClient({ url: rpcUrl });
+  }
+
+  const result = await execute(api);
+  return result;
+}
+
+export const getBalanceCached = makeLRUCache(
+  ({ api, owner }: { api: SuiClient; owner: string }) => api.getBalance({ owner }),
+  (params: { api: SuiClient; owner: string }) => params.owner,
+  minutes(1),
+);
+
+/**
+ * Get account balance
+ */
+export const getAccount = async (addr: string) =>
+  withApi(async api => {
+    const balance = await getBalanceCached({ api, owner: addr });
+    return {
+      blockHeight: BLOCK_HEIGHT * 2,
+      balance: BigNumber(balance.totalBalance),
+    };
+  });
+
+/**
+ * Returns true if account is the signer
+ */
+export function isSender(addr: string, transaction?: TransactionBlockData): boolean {
+  return transaction?.sender === ensureAddressFormat(addr);
+}
+
+/**
+ * Map transaction to an Operation Type
+ */
+export function getOperationType(addr: string, transaction?: TransactionBlockData): OperationType {
+  return isSender(addr, transaction) ? "OUT" : "IN";
+}
+
+/**
+ * Extract senders from transaction
+ */
+export const getOperationSenders = (transaction?: TransactionBlockData): string[] => {
+  return transaction?.sender ? [transaction?.sender] : [];
+};
+
+/**
+ * Extract recipients from transaction
+ */
+export const getOperationRecipients = (transaction?: TransactionBlockData): string[] => {
+  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));
+      }
+    });
+    return recipients;
+  }
+  return [];
+};
+
+/**
+ * Extract value from transaction
+ */
+export const getOperationAmount = (
+  address: string,
+  transaction: SuiTransactionBlockResponse,
+): BigNumber => {
+  let amount = new BigNumber(0);
+  if (!transaction?.balanceChanges) return amount;
+  for (const balanceChange of transaction.balanceChanges) {
+    if (
+      typeof balanceChange.owner !== "string" &&
+      "AddressOwner" in balanceChange.owner &&
+      balanceChange.owner.AddressOwner === address
+    ) {
+      if (balanceChange.amount[0] === "-") {
+        amount = amount.minus(balanceChange.amount);
+      } else {
+        amount = amount.plus(balanceChange.amount);
+      }
+    }
+  }
+  return amount;
+};
+
+/**
+ * Extract fee from transaction
+ */
+export const getOperationFee = (transaction: SuiTransactionBlockResponse): BigNumber => {
+  const gas = transaction.effects!.gasUsed;
+
+  const computationCost = BigNumber(gas.computationCost);
+  const storageCost = BigNumber(gas.storageCost);
+  const storageRebate = BigNumber(gas.storageRebate);
+
+  return computationCost.plus(storageCost).minus(storageRebate);
+};
+
+/**
+ * Extract date from transaction
+ */
+export const getOperationDate = (transaction: SuiTransactionBlockResponse): Date => {
+  return new Date(parseInt(transaction.timestampMs!));
+};
+
+/**
+ * Map the Sui history transaction to a Ledger Live Operation
+ */
+export function transactionToOperation(
+  accountId: string,
+  address: string,
+  transaction: SuiTransactionBlockResponse,
+): Operation {
+  const type = getOperationType(address, transaction.transaction?.data);
+  const hash = transaction.digest;
+  return {
+    id: encodeOperationId(accountId, hash, type),
+    accountId,
+    blockHash: hash,
+    blockHeight: BLOCK_HEIGHT,
+    date: getOperationDate(transaction),
+    extra: {},
+    fee: getOperationFee(transaction),
+    hasFailed: transaction.effects?.status.status != "success",
+    hash,
+    recipients: getOperationRecipients(transaction.transaction?.data),
+    senders: getOperationSenders(transaction.transaction?.data),
+    type,
+    value: getOperationAmount(address, transaction),
+  };
+}
+
+/**
+ * Fetch operation list
+ */
+export const getOperations = async (
+  accountId: string,
+  addr: string,
+  inCursor?: string | null | undefined,
+  outCursor?: string | null | undefined,
+): Promise<Operation[]> =>
+  withApi(async api => {
+    const sentOps = await loadOperation({ api, type: "OUT", addr, cursor: outCursor });
+    const receivedOps = await loadOperation({ api, type: "IN", addr, cursor: inCursor });
+    const rawTransactions = [...sentOps, ...receivedOps].sort(
+      (a, b) => Number(b.timestampMs) - Number(a.timestampMs),
+    );
+
+    return rawTransactions.map(transaction => transactionToOperation(accountId, addr, transaction));
+  });
+
+const getTotalGasUsed = (effects?: TransactionEffects | null): bigint => {
+  const gasSummary = effects?.gasUsed;
+  if (!gasSummary) return BigInt(0);
+  return (
+    BigInt(gasSummary.computationCost) +
+    BigInt(gasSummary.storageCost) -
+    BigInt(gasSummary.storageRebate)
+  );
+};
+
+export const paymentInfo = async (sender: string, fakeTransaction: TransactionType) =>
+  withApi(async api => {
+    const tx = new Transaction();
+    tx.setSender(ensureAddressFormat(sender));
+    const [coin] = tx.splitCoins(tx.gas, [fakeTransaction.amount.toNumber()]);
+    tx.transferObjects([coin], fakeTransaction.recipient);
+    const txb = await tx.build({ client: api });
+    const dryRunTxResponse = await api.dryRunTransactionBlock({ transactionBlock: txb });
+    const fees = getTotalGasUsed(dryRunTxResponse.effects);
+    return {
+      gasBudget: dryRunTxResponse.input.gasData.budget,
+      totalGasUsed: fees,
+      fees,
+    };
+  });
+
+export const createTransaction = async (address: string, transaction: CreateExtrinsicArg) =>
+  withApi(async api => {
+    const tx = new Transaction();
+    tx.setSender(ensureAddressFormat(address));
+
+    const [coin] = tx.splitCoins(tx.gas, [transaction.amount.toNumber()]);
+    tx.transferObjects([coin], transaction.recipient);
+
+    return tx.build({ client: api });
+  });
+
+export const executeTransactionBlock = async (params: ExecuteTransactionBlockParams) =>
+  withApi(async api => {
+    return api.executeTransactionBlock(params);
+  });
+
+// load from curos point or from begining until we reach the end
+const loadOperation = async (params: {
+  api: SuiClient;
+  type: OperationType;
+  addr: string;
+  cursor?: string | null | undefined;
+}): Promise<PaginatedTransactionResponse["data"]> => {
+  const { api, addr, type, cursor } = params;
+  const filter: QueryTransactionBlocksParams["filter"] =
+    type === "IN" ? { ToAddress: addr } : { FromAddress: addr };
+
+  const { data, nextCursor, hasNextPage } = await api.queryTransactionBlocks({
+    filter,
+    cursor,
+    order: "ascending",
+    options: {
+      showInput: true,
+      showBalanceChanges: true,
+      showEffects: true, // To get transaction status and gas fee details
+    },
+    limit: TRANSACTIONS_REQUEST_LIMIT,
+  });
+
+  if (hasNextPage) {
+    const newData = await loadOperation({ api, type, addr, cursor: nextCursor });
+    return [...newData, ...data];
+  }
+
+  return data;
+};

package/src/signer/getAddress.test.ts

@@ -0,0 +1,119 @@
+import getAddressResolver from "./";
+
+describe("getAddress resolver", () => {
+  const mockDeviceId = "mock-device-id";
+  const mockPath = "44'/784'/0'/0'/0'";
+
+  it("should successfully resolve an address", async () => {
+    // Mock address and public key data
+    const mockAddress = Buffer.from("0x123abc");
+    const mockPublicKey = Buffer.from("deadbeef");
+
+    const mockSigner = {
+      getPublicKey: jest.fn().mockResolvedValue({
+        address: mockAddress,
+        publicKey: mockPublicKey,
+      }),
+    };
+
+    const mockSignerContext = jest
+      .fn()
+      .mockImplementation((deviceId, callback) => callback(mockSigner));
+
+    const getAddress = getAddressResolver(mockSignerContext);
+
+    const result = await getAddress(mockDeviceId, {
+      currency: {
+        type: "CryptoCurrency",
+        id: "sui",
+        coinType: 784,
+        name: "Sui",
+        managerAppName: "Sui",
+        ticker: "SUI",
+        scheme: "sui",
+        color: "#000",
+        family: "sui",
+        units: [{ name: "Sui", code: "SUI", magnitude: 9 }],
+        explorerViews: [],
+      },
+      path: "44'/784'/0'/0'/0'",
+      derivationMode: "sui",
+    });
+
+    expect(result).toEqual({
+      address: "0x" + mockAddress.toString("hex"),
+      publicKey: mockPublicKey.toString("hex"),
+      path: mockPath,
+    });
+  });
+
+  it("should throw error when address is missing", async () => {
+    const mockSigner = {
+      getPublicKey: jest.fn().mockResolvedValue({
+        address: null,
+        publicKey: Buffer.from("deadbeef"),
+      }),
+    };
+
+    const mockSignerContext = jest
+      .fn()
+      .mockImplementation((deviceId, callback) => callback(mockSigner));
+
+    const getAddress = getAddressResolver(mockSignerContext);
+
+    await expect(
+      getAddress(mockDeviceId, {
+        currency: {
+          type: "CryptoCurrency",
+          id: "sui",
+          coinType: 784,
+          name: "Sui",
+          managerAppName: "Sui",
+          ticker: "SUI",
+          scheme: "sui",
+          color: "#000",
+          family: "sui",
+          units: [{ name: "Sui", code: "SUI", magnitude: 9 }],
+          explorerViews: [],
+        },
+        path: "44'/784'/0'/0'/0'",
+        derivationMode: "sui",
+      }),
+    ).rejects.toThrow("Failed to get address from device");
+  });
+
+  it("should throw error when publicKey is missing", async () => {
+    const mockSigner = {
+      getPublicKey: jest.fn().mockResolvedValue({
+        address: Buffer.from("0x123abc"),
+        publicKey: null,
+      }),
+    };
+
+    const mockSignerContext = jest
+      .fn()
+      .mockImplementation((deviceId, callback) => callback(mockSigner));
+
+    const getAddress = getAddressResolver(mockSignerContext);
+
+    await expect(
+      getAddress(mockDeviceId, {
+        currency: {
+          type: "CryptoCurrency",
+          id: "sui",
+          coinType: 784,
+          name: "Sui",
+          managerAppName: "Sui",
+          ticker: "SUI",
+          scheme: "sui",
+          color: "#000",
+          family: "sui",
+          units: [{ name: "Sui", code: "SUI", magnitude: 9 }],
+          explorerViews: [],
+        },
+        path: "44'/784'/0'/0'/0'",
+        derivationMode: "sui",
+      }),
+    ).rejects.toThrow("Failed to get address from device");
+  });
+});

package/src/signer/getAddress.ts

@@ -0,0 +1,26 @@
+import { log } from "@ledgerhq/logs";
+import type { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import type { SuiSigner } from "../types";
+import { ensureAddressFormat } from "../utils";
+
+const resolver = (signerContext: SignerContext<SuiSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    log("debug", "start getAddress process");
+
+    const result = await signerContext(deviceId, signer => signer.getPublicKey(path, verify));
+
+    if (!result.address || !result.publicKey) {
+      throw Error("Failed to get address from device");
+    }
+
+    return {
+      address: ensureAddressFormat(Buffer.from(result.address).toString("hex")),
+      publicKey: Buffer.from(result.publicKey).toString("hex"),
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1,7 @@
+/**
+ * This directory is the home for all types and logic based on Ledgers signer.
+ */
+
+import getAddress from "./getAddress";
+
+export default getAddress;

package/src/test/cli.ts

@@ -0,0 +1,21 @@
+type Options =
+  | { name: string; type: StringConstructor; desc: string }
+  | { name: string; type: StringConstructor; desc: string; multiple: boolean };
+
+const options: Array<Options> = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send",
+  },
+];
+
+export type CliTools = {
+  options: Array<Options>;
+};
+
+export default function makeCliTools(): CliTools {
+  return {
+    options,
+  };
+}

package/src/types/bridge.fixture.ts

@@ -0,0 +1,84 @@
+import { BigNumber } from "bignumber.js";
+import { SuiAccount } from "./bridge";
+
+export const createFixtureAccount = (overrides = {}) =>
+  ({
+    type: "Account",
+    id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+    used: true,
+    seedIdentifier: "99807c4b6e1b8b25120f633f5f7816a393e4d3e7f84bdf24bd8afe725911be91",
+    derivationMode: "sui",
+    index: 0,
+    freshAddress: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+    freshAddressPath: "44'/784'/0'/0'/0'",
+    blockHeight: 10,
+    creationDate: new Date(),
+    balance: BigNumber(17997970360),
+    spendableBalance: BigNumber(17997970360),
+    operations: [],
+    operationsCount: 2,
+    pendingOperations: [],
+    currency: {
+      type: "CryptoCurrency",
+      id: "sui",
+      coinType: 784,
+      name: "Sui",
+      managerAppName: "Sui",
+      ticker: "SUI",
+      scheme: "sui",
+      color: "#000",
+      family: "sui",
+      units: [{ name: "Sui", code: "SUI", magnitude: 9 }],
+      explorerViews: [
+        {
+          tx: "https://suiscan.xyz/mainnet/tx/$hash",
+          address: "https://suiscan.xyz/mainnet/account/$address",
+        },
+        {
+          tx: "https://suivision.xyz/txblock/$hash",
+          address: "https://suivision.xyz/account/$address",
+        },
+      ],
+    },
+    lastSyncDate: new Date(),
+    swapHistory: [],
+    balanceHistoryCache: {
+      HOUR: {
+        balances: [0],
+        latestDate: new Date().getMilliseconds(),
+      },
+      DAY: { balances: [0], latestDate: new Date().getMilliseconds() },
+      WEEK: { balances: [0], latestDate: new Date().getMilliseconds() },
+    },
+    subAccounts: [],
+    suiResources: { nonce: 0 },
+    ...overrides,
+  }) as SuiAccount;
+
+export const createFixtureTransaction = (overrides = {}) => ({
+  family: "sui" as const,
+  mode: "send",
+  amount: BigNumber(3000000000),
+  recipient: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
+  useAllAmount: false,
+  fees: BigNumber(3976000),
+  errors: {},
+  skipVerify: true,
+  ...overrides,
+});
+
+export const createFixtureOperation = (overrides = {}) => ({
+  hash: "44298e5b1b7d73efc",
+  fee: BigNumber(3976000),
+  blockHash: null,
+  blockHeight: null,
+  extra: { transferAmount: BigNumber(1000000000) },
+  id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui--OUT",
+  type: "OUT" as const,
+  value: BigNumber(1003976000),
+  senders: ["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"],
+  recipients: ["0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24"],
+  accountId: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+  date: new Date(),
+  ...overrides,
+});

package/src/types/bridge.ts

@@ -0,0 +1,95 @@
+import type { BigNumber } from "bignumber.js";
+import type {
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+  Operation,
+  OperationRaw,
+} from "@ledgerhq/types-live";
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
+
+/**
+ * Sui account resources
+ */
+export type SuiResources = object;
+
+/**
+ * Sui account resources from raw JSON
+ */
+export type SuiResourcesRaw = object;
+
+/**
+ * Sui transaction
+ */
+export type Transaction = TransactionCommon & {
+  mode: string;
+  family: "sui";
+  amount: BigNumber | null;
+  fees?: BigNumber | null;
+  errors: Record<string, Error>;
+  skipVerify?: boolean;
+  // add here all transaction-specific fields when implement other modes than "send"
+};
+
+/**
+ * Sui transaction from a raw JSON
+ */
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "sui";
+  mode: string;
+  fees?: string;
+  // also the transaction fields as raw JSON data
+};
+
+/**
+ * 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 SuiAccount = Account & {
+  // On some blockchain, an account can have resources (gained, delegated, ...)
+  suiResources?: SuiResources;
+};
+
+export type SuiAccountRaw = AccountRaw & {
+  suiResources?: SuiResourcesRaw;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type SuiOperation = Operation<SuiOperationExtra>;
+export type SuiOperationRaw = OperationRaw<SuiOperationExtraRaw>;
+
+export type SuiOperationExtra = {
+  transferAmount?: BigNumber;
+};
+export type SuiOperationExtraRaw = Record<string, string>;
+
+export type SuiSignedOperation = {
+  operation: SuiOperation;
+  signature: string;
+  rawData: {
+    unsigned: string;
+    serializedSignature: string;
+  };
+};
+
+export type TransferCommand = {
+  kind: "transfer";
+  sender: string;
+  recipient: string;
+  amount: number;
+};
+
+export type Command = TransferCommand;
+
+export type CommandDescriptor = {
+  command: Command;
+  fee: number;
+  warnings: Record<string, Error>;
+  errors: Record<string, Error>;
+};

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./bridge";
+export * from "./model";
+export * from "./signer";

package/src/types/model.ts

@@ -0,0 +1,7 @@
+export type SuiOperationMode = "send";
+
+export type AccountInfoResponse = Record<string, string>;
+
+export type CoreTransaction = {
+  unsigned: Uint8Array;
+};

package/src/types/signer.ts

@@ -0,0 +1,12 @@
+import Sui from "@ledgerhq/hw-app-sui";
+
+export type SuiAddress = {
+  pubKey: string;
+  address: string;
+  return_code: number;
+};
+export type SuiSignature = {
+  signature: null | string;
+  return_code: number;
+};
+export interface SuiSigner extends Sui {}

package/src/utils.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensures that the address is in the format `0x...`
+ * @param addr The address to ensure the format of
+ * @returns The address in the format `0x...`
+ */
+export function ensureAddressFormat(addr: string): `0x${string}` {
+  return (addr?.startsWith("0x") ? addr : `0x${addr}`) as `0x${string}`;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "rootDir": "./src",
+    "exactOptionalPropertyTypes": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*"]
+}