@ledgerhq/coin-sui 0.2.0-nightly.0

package/src/bridge/broadcast.ts

@@ -0,0 +1,21 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { broadcast as logicBroadcast } from "../logic";
+import { SuiSignedOperation, Transaction } from "../types";
+
+/**
+ * Broadcast the signed transaction
+ * @param {Object} params - The parameters for broadcasting the transaction.
+ * @param {Object} params.signedOperation - The signed operation to be broadcasted.
+ * @param {Object} params.signedOperation.operation - The operation details.
+ * @param {Object} params.signedOperation.rawData - The raw data of the signed operation.
+ * @returns {Promise<Object>} The operation with the hash of the transaction.
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signedOperation }) => {
+  const {
+    operation,
+    rawData: { unsigned, serializedSignature },
+  } = signedOperation as unknown as SuiSignedOperation;
+  const hash = await logicBroadcast(unsigned, serializedSignature);
+  return patchOperationWithHash(operation, hash);
+};

package/src/bridge/buildOptimisticOperation.test.ts

@@ -0,0 +1,53 @@
+import BigNumber from "bignumber.js";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { SuiAccount, Transaction } from "../types";
+
+describe("buildOptimisticOperation", () => {
+  it("should build optimistic operation for transfer", () => {
+    // GIVEN
+    const account: SuiAccount = createFixtureAccount();
+    const transaction: Transaction = createFixtureTransaction();
+    const fee = new BigNumber(10);
+
+    // WHEN
+    const result = buildOptimisticOperation(account, transaction, fee);
+
+    // THEN
+    expect(result).toEqual({
+      id: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui--OUT",
+      hash: "",
+      type: "OUT",
+      value: transaction.amount.plus(fee), // amount + fee
+      fee: new BigNumber(10),
+      senders: ["0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0"],
+      recipients: ["0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24"],
+      accountId: "js:2:sui:0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0:sui",
+      date: expect.any(Date),
+      blockHash: null,
+      blockHeight: null,
+      extra: {
+        transferAmount: new BigNumber(3000000000),
+      },
+    });
+  });
+
+  it("should calculate correct value for OUT type", () => {
+    // GIVEN
+    const account: SuiAccount = createFixtureAccount();
+    const transaction: Transaction = createFixtureTransaction();
+    const amount = new BigNumber(500);
+    const fee = new BigNumber(50);
+    const tx = {
+      ...transaction,
+      amount,
+    };
+
+    // WHEN
+    const result = buildOptimisticOperation(account, tx, fee);
+
+    // THEN
+    expect(result.value).toEqual(amount.plus(fee));
+    expect(result.fee).toEqual(fee);
+  });
+});

package/src/bridge/buildOptimisticOperation.ts

@@ -0,0 +1,105 @@
+import BigNumber from "bignumber.js";
+import type { Account, OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import {
+  CommandDescriptor,
+  SuiAccount,
+  SuiOperation,
+  SuiOperationExtra,
+  SuiOperationMode,
+  Transaction,
+} from "../types";
+import { assertUnreachable } from "./utils";
+
+const MODE_TO_TYPE: Record<SuiOperationMode | "default", OperationType> = {
+  send: "OUT",
+  default: "OUT",
+};
+
+const getExtra = (type: string, transaction: Transaction): SuiOperationExtra => {
+  const extra: SuiOperationExtra = {};
+
+  switch (type) {
+    case "OUT":
+      return { ...extra, transferAmount: new BigNumber(transaction.amount) };
+  }
+
+  return extra;
+};
+
+export const buildOptimisticOperation = (
+  account: SuiAccount,
+  transaction: Transaction,
+  fee: BigNumber,
+): SuiOperation => {
+  const commandDescriptor: CommandDescriptor = {
+    command: {
+      kind: "transfer" as const,
+      sender: account.freshAddress,
+      recipient: transaction.recipient,
+      amount: transaction.amount.toNumber(),
+    },
+    fee: fee.toNumber(),
+    warnings: {},
+    errors: {},
+  };
+
+  const optimisticOperation = buildOptimisticOperationForCommand(
+    account,
+    transaction,
+    commandDescriptor,
+  );
+
+  return optimisticOperation;
+};
+
+function buildOptimisticOperationForCommand(
+  account: Account,
+  transaction: Transaction,
+  commandDescriptor: CommandDescriptor,
+): SuiOperation {
+  const { command } = commandDescriptor;
+  switch (command.kind) {
+    case "transfer":
+      return optimisticOpForTransfer(account, transaction, commandDescriptor);
+    default:
+      // @ts-expect-error Seem like a bug in TS, remove once more commands are added
+      return assertUnreachable(command);
+  }
+}
+
+function optimisticOpForTransfer(
+  account: Account,
+  transaction: Transaction,
+  commandDescriptor: CommandDescriptor,
+): SuiOperation {
+  const type = MODE_TO_TYPE.default;
+  const value =
+    type === "OUT"
+      ? new BigNumber(transaction.amount).plus(commandDescriptor.fee)
+      : new BigNumber(commandDescriptor.fee);
+  const extra = getExtra(type, transaction);
+
+  const commons = optimisticOpcommons(commandDescriptor);
+  return {
+    ...commons,
+    id: encodeOperationId(account.id, "", type),
+    type,
+    value,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient].filter(Boolean),
+    accountId: account.id,
+    date: new Date(),
+    extra,
+  };
+}
+
+function optimisticOpcommons(commandDescriptor: CommandDescriptor) {
+  return {
+    hash: "",
+    fee: new BigNumber(commandDescriptor.fee),
+    blockHash: null,
+    blockHeight: null,
+    extra: {},
+  };
+}

package/src/bridge/buildTransaction.test.ts

@@ -0,0 +1,17 @@
+import { buildTransaction } from "./buildTransaction";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+
+describe("buildTransaction", () => {
+  it("returns unsigned tx bytes for given tx", async () => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const transaction = createFixtureTransaction();
+
+    // WHEN
+    const result = await buildTransaction(account, transaction);
+
+    // THEN
+    expect(result).not.toBeNull();
+    expect(result.unsigned).toBeInstanceOf(Uint8Array);
+  });
+});

package/src/bridge/buildTransaction.ts

@@ -0,0 +1,14 @@
+import pick from "lodash/pick";
+import type { SuiAccount, Transaction } from "../types";
+import { craftTransaction, type CreateExtrinsicArg } from "../logic";
+
+export const extractExtrinsicArg = (transaction: Transaction): CreateExtrinsicArg =>
+  pick(transaction, ["mode", "amount", "recipient", "useAllAmount"]);
+
+/**
+ * @param {Account} account
+ * @param {Transaction} transaction
+ */
+export const buildTransaction = async (account: SuiAccount, transaction: Transaction) => {
+  return craftTransaction(account.freshAddress, extractExtrinsicArg(transaction));
+};

package/src/bridge/createTransaction.ts

@@ -0,0 +1,23 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "../types";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  const transaction: Transaction = {
+    family: "sui" as const,
+    mode: "send",
+    amount: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+    fees: null,
+    errors: {},
+  };
+  return transaction;
+};
+
+export default createTransaction;

package/src/bridge/estimateMaxSpendable.test.ts

@@ -0,0 +1,27 @@
+import { BigNumber } from "bignumber.js";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+import { SuiAccount, Transaction } from "../types";
+
+const mockEstimateFees = jest.fn();
+jest.mock("../logic", () => ({
+  estimateFees: () => mockEstimateFees(),
+}));
+
+describe("estimateMaxSpendable", () => {
+  it("should return the correct spendable amount when fees are deducted", async () => {
+    // GIVEN
+    const balance = new BigNumber(100);
+    const account: SuiAccount = createFixtureAccount({ spendableBalance: balance });
+    const transaction: Transaction = createFixtureTransaction();
+    const fees = new BigNumber(10);
+    mockEstimateFees.mockResolvedValue(fees);
+
+    // WHEN
+    const result = await estimateMaxSpendable({ account, transaction });
+
+    // THEN
+    expect(mockEstimateFees).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(balance.minus(fees));
+  });
+});

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,46 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import type { SuiAccount, Transaction } from "../types";
+import getFeesForTransaction from "./getFeesForTransaction";
+import createTransaction from "./createTransaction";
+import { BigNumber } from "bignumber.js";
+
+/**
+ * Returns the maximum possible amount for transaction
+ * @typedef {Object} EstimateMaxSpendableParams
+ * @property {SuiAccount} account - The account from which to estimate the maximum spendable amount.
+ * @property {SuiAccount} [parentAccount] - The parent account, if applicable.
+ * @property {Transaction} transaction - The transaction details for which to estimate the maximum spendable amount.
+ *
+ * @returns {Promise<BigNumber>} The estimated maximum spendable amount.
+ */
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  try {
+    const mainAccount = getMainAccount(account, parentAccount) as SuiAccount;
+
+    const estimatedTransaction = {
+      ...createTransaction(account),
+      ...transaction,
+      useAllAmount: true,
+    };
+    const fees = await getFeesForTransaction({
+      account: mainAccount,
+      transaction: estimatedTransaction,
+    });
+
+    let spendableBalance = mainAccount.spendableBalance;
+    if (fees) {
+      spendableBalance = BigNumber.max(spendableBalance.minus(fees), 0);
+    }
+
+    return spendableBalance;
+  } catch (e) {
+    return new BigNumber(0);
+  }
+};
+
+export default estimateMaxSpendable;

package/src/bridge/formatters.test.ts

@@ -0,0 +1,17 @@
+import { fromOperationExtraRaw, toOperationExtraRaw } from "./formatters";
+
+describe("formatters", () => {
+  describe("fromOperationExtraRaw", () => {
+    it("should return an empty object when no extraRaw is provided", () => {
+      const result = fromOperationExtraRaw(undefined);
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("toOperationExtraRaw", () => {
+    it("should return an empty object when no extra is provided", () => {
+      const result = toOperationExtraRaw(undefined);
+      expect(result).toEqual({});
+    });
+  });
+});

package/src/bridge/formatters.ts

@@ -0,0 +1,26 @@
+import { OperationExtra, OperationExtraRaw } from "@ledgerhq/types-live";
+import type { SuiOperationExtra, SuiOperationExtraRaw } from "../types";
+
+export function fromOperationExtraRaw(extraRaw: OperationExtraRaw) {
+  if (extraRaw) {
+    // reserved for future use
+  }
+
+  const extra: SuiOperationExtra = {};
+
+  return extra;
+}
+
+export function toOperationExtraRaw(extra: OperationExtra) {
+  if (extra) {
+    // reserved for future use
+  }
+  const extraRaw: SuiOperationExtraRaw = {};
+
+  return extraRaw;
+}
+
+export default {
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+};

package/src/bridge/getFeesForTransaction.test.ts

@@ -0,0 +1,36 @@
+import getEstimatedFees from "./getFeesForTransaction";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+
+const estimateFees = jest.fn();
+
+jest.mock("../logic", () => {
+  return {
+    estimateFees: (arg: any) => estimateFees(arg),
+  };
+});
+
+describe("getEstimatedFees", () => {
+  const transaction = createFixtureTransaction();
+
+  beforeEach(() => {
+    estimateFees.mockClear();
+  });
+
+  it("returns fees estimation by sui sdk", async () => {
+    // GIVEN
+    const account = createFixtureAccount();
+    const gasBudget = BigInt("3976000");
+    estimateFees.mockResolvedValue(gasBudget);
+
+    // WHEN
+    const result = await getEstimatedFees({
+      account,
+      transaction,
+    });
+
+    // THEN
+    expect(estimateFees).toHaveBeenCalledTimes(1);
+    expect(estimateFees.mock.lastCall).not.toBeNull();
+    expect(result.toString()).toEqual(gasBudget.toString());
+  });
+});

package/src/bridge/getFeesForTransaction.ts

@@ -0,0 +1,37 @@
+import { BigNumber } from "bignumber.js";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import type { SuiAccount, Transaction } from "../types";
+import { calculateAmount } from "./utils";
+import { estimateFees } from "../logic";
+
+/**
+ * Fetch the transaction fees for a transaction
+ *
+ * @param {Object} params
+ * @param {SuiAccount} params.account - The account to estimate fees for
+ * @param {Transaction} params.transaction - The transaction to estimate fees for
+ * @returns {Promise<BigNumber>} The estimated fees
+ */
+export default async function getEstimatedFees({
+  account,
+  transaction,
+}: {
+  account: SuiAccount;
+  transaction: Transaction;
+}): Promise<BigNumber> {
+  const t = {
+    ...transaction,
+    recipient: getAbandonSeedAddress(account.currency.id),
+    // Always use a fake recipient to estimate fees
+    amount: calculateAmount({
+      account,
+      transaction: {
+        ...transaction,
+        fees: new BigNumber(transaction.fees || 0),
+      },
+    }), // Remove fees if present since we are fetching fees
+  };
+
+  const fees = await estimateFees(account.freshAddress, t);
+  return new BigNumber(fees.toString());
+}

package/src/bridge/getTransactionStatus.test.ts

@@ -0,0 +1,57 @@
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+  FeeNotLoaded,
+} from "@ledgerhq/errors";
+import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
+import getTransactionStatus from "./getTransactionStatus";
+
+const account = createFixtureAccount();
+
+describe("getTransactionStatus", () => {
+  it("should return errors if recipient empty", async () => {
+    const transaction = createFixtureTransaction({ recipient: null });
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = { recipient: new RecipientRequired() };
+    expect(result.errors).toEqual(expected);
+  });
+  it("should return errors if recipient is invalid sui adress", async () => {
+    const transaction = createFixtureTransaction({ recipient: "notValidSuiAddress" });
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = { recipient: new InvalidAddress() };
+    expect(result.errors).toEqual(expected);
+  });
+  it("should return errors if recipient equals to sender", async () => {
+    const transaction = createFixtureTransaction({ recipient: account.freshAddress });
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = { recipient: new InvalidAddressBecauseDestinationIsAlsoSource() };
+    expect(result.errors).toEqual(expected);
+  });
+  it("should return errors if amount not provided", async () => {
+    const transaction = createFixtureTransaction({ amount: null });
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = { amount: new AmountRequired() };
+    expect(result.errors).toEqual(expected);
+  });
+  it("should return errors if amount exceeds balance", async () => {
+    const transaction = createFixtureTransaction({ amount: account.balance.plus(1) });
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = { amount: new NotEnoughBalance() };
+    expect(result.errors).toEqual(expected);
+  });
+  it("should return errors if amount exceeds balance", async () => {
+    const transaction = createFixtureTransaction({ fees: null });
+    const result = await getTransactionStatus(account, transaction);
+
+    const expected = { fees: new FeeNotLoaded() };
+    expect(result.errors).toEqual(expected);
+  });
+});

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,73 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+  FeeNotLoaded,
+  FeeTooHigh,
+} from "@ledgerhq/errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+import type { SuiAccount, Transaction, TransactionStatus } from "../types";
+import { isValidSuiAddress } from "@mysten/sui/utils";
+import { ensureAddressFormat } from "../utils";
+
+/**
+ * Get the status of a transaction.
+ * @function getTransactionStatus
+ * @param {SuiAccount} account - The account associated with the transaction.
+ * @param {Transaction} transaction - The transaction object containing details such as amount, fees, and recipient.
+ * @returns {Promise<Object>} A promise that resolves to an object containing the transaction status, including errors, warnings, estimated fees, amount, and total spent.
+ */
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  SuiAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const amount = new BigNumber(transaction?.amount || 0);
+  const estimatedFees = new BigNumber(transaction?.fees || 0);
+  const totalSpent = amount.plus(estimatedFees);
+
+  if (amount.lte(0)) {
+    errors.amount = new AmountRequired();
+  } else if (estimatedFees.times(10).gt(amount)) {
+    warnings.feeTooHigh = new FeeTooHigh();
+  }
+
+  if (transaction) {
+    if (!transaction.recipient) {
+      errors.recipient = new RecipientRequired();
+    } else if (!isValidSuiAddress(transaction.recipient)) {
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: account.currency.name,
+      });
+    }
+
+    if (ensureAddressFormat(account.freshAddress) === ensureAddressFormat(transaction.recipient)) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    }
+
+    if (totalSpent.eq(0) && transaction.useAllAmount) {
+      errors.amount = new NotEnoughBalance();
+    }
+    if (totalSpent.gt(account.balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+    if (!transaction.fees) {
+      errors.fees = new FeeNotLoaded();
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount: amount.lt(0) ? new BigNumber(0) : amount,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;

package/src/bridge/index.ts

@@ -0,0 +1,77 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  getSerializedAddressParameters,
+  updateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import suiConfig, { type SuiCoinConfig } from "../config";
+import signerGetAddress from "../signer";
+import { SuiAccount, SuiSigner, TransactionStatus, type Transaction } from "../types";
+import { broadcast } from "./broadcast";
+import { createTransaction } from "./createTransaction";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { getPreloadStrategy, hydrate, preload } from "./preload";
+import { prepareTransaction } from "./prepareTransaction";
+import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
+import { fromOperationExtraRaw, toOperationExtraRaw } from "./formatters";
+import { buildSignOperation } from "./signOperation";
+import { getAccountShape, sync } from "./synchronisation";
+
+function buildCurrencyBridge(signerContext: SignerContext<SuiSigner>): CurrencyBridge {
+  const getAddress = signerGetAddress(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    getPreloadStrategy,
+    preload,
+    hydrate,
+    scanAccounts,
+  };
+}
+
+function buildAccountBridge(
+  signerContext: SignerContext<SuiSigner>,
+): AccountBridge<Transaction, SuiAccount, TransactionStatus> {
+  const getAddress = signerGetAddress(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    assignFromAccountRaw,
+    assignToAccountRaw,
+    fromOperationExtraRaw,
+    toOperationExtraRaw,
+    getSerializedAddressParameters,
+  };
+}
+
+export function createBridges(
+  signerContext: SignerContext<SuiSigner>,
+  coinConfig: CoinConfig<SuiCoinConfig>,
+) {
+  suiConfig.setCoinConfig(coinConfig);
+
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}