@ledgerhq/coin-aptos 1.4.0-next.0

package/src/__tests__/bridge/transaction.test.ts

@@ -0,0 +1,261 @@
+import BigNumber from "bignumber.js";
+import { createFixtureAccount, createFixtureTransaction } from "../../bridge/bridge.fixture";
+import { formatTransaction, fromTransactionRaw, toTransactionRaw } from "../../bridge/transaction";
+import { Transaction, TransactionRaw } from "../../types";
+
+describe("transaction Test", () => {
+  describe("when formatTransaction", () => {
+    describe("when amount is 0 and fee is 0", () => {
+      it("should return a transaction SEND to 0xff00 with fees=?", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.recipient = "0xff00";
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND 
+TO 0xff00
+with fees=?`;
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe("when amount is 0 and fee is 0.0001", () => {
+      it("should return a transaction SEND to 0xff00 with fees=0", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.recipient = "0xff00";
+        transaction.fees = BigNumber("0.0001");
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND 
+TO 0xff00
+with fees=0`;
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe("when amount is 0 and fee is 0.1", () => {
+      it("should return a transaction SEND to 0xff00 with fees=0", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.recipient = "0xff00";
+        transaction.fees = BigNumber("0.1");
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND 
+TO 0xff00
+with fees=0`;
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe("when amount is 1 and fee is 0.1", () => {
+      it("should return a transaction SEND to 0xff00 with fees=0", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.amount = BigNumber("1");
+        transaction.recipient = "0xff00";
+        transaction.fees = BigNumber("0.1");
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND  0.00000001
+TO 0xff00
+with fees=0`;
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe("when amount is 10 and fee is 1", () => {
+      it("should return a transaction SEND to 0xff00 with fees=0", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.amount = BigNumber("10");
+        transaction.recipient = "0xff00";
+        transaction.fees = BigNumber("1");
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND  0.0000001
+TO 0xff00
+with fees=0.00000001`;
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe("when amount is 1000 and fee is 1", () => {
+      it("should return a transaction SEND to 0xff00 with fees=0", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.amount = BigNumber("1000");
+        transaction.recipient = "0xff00";
+        transaction.fees = BigNumber("1");
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND  0.00001
+TO 0xff00
+with fees=0.00000001`;
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe("when using MAX with amount is 1000 and fee is 1", () => {
+      it("should return a transaction SEND to 0xff00 with fees=0", async () => {
+        const account = createFixtureAccount();
+        const transaction = createFixtureTransaction();
+
+        transaction.amount = BigNumber("1000");
+        transaction.useAllAmount = true;
+        transaction.recipient = "0xff00";
+        transaction.fees = BigNumber("1");
+        const result = formatTransaction(transaction, account);
+
+        const expected = `
+SEND MAX
+TO 0xff00
+with fees=0.00000001`;
+
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  describe("when fromTransactionRaw", () => {
+    it("should return the transaction object", () => {
+      const txRaw = {
+        family: "aptos",
+        mode: "send",
+        options: "{}",
+        amount: "0.5",
+        recipient: "0xff00",
+        useAllAmount: false,
+        subAccountId: "0xff01",
+        recipientDomain: {},
+      } as TransactionRaw;
+
+      const result = fromTransactionRaw(txRaw);
+
+      const expected = {
+        family: "aptos",
+        amount: BigNumber("0.5"),
+        options: {},
+        mode: "send",
+        recipient: "0xff00",
+        recipientDomain: {},
+        subAccountId: "0xff01",
+        useAllAmount: false,
+      };
+
+      expect(result).toEqual(expected);
+    });
+
+    it("should return the transaction object with fees and errors", () => {
+      const txRaw = {
+        family: "aptos",
+        mode: "send",
+        fees: "50",
+        errors: '{ "errors": "error" }',
+        options: "{}",
+        amount: "0.5",
+        recipient: "0xff00",
+        useAllAmount: false,
+        subAccountId: "0xff01",
+        recipientDomain: {},
+      } as TransactionRaw;
+
+      const result = fromTransactionRaw(txRaw);
+
+      const expected = {
+        family: "aptos",
+        amount: BigNumber("0.5"),
+        fees: BigNumber(50),
+        errors: { errors: "error" },
+        options: {},
+        mode: "send",
+        recipient: "0xff00",
+        recipientDomain: {},
+        subAccountId: "0xff01",
+        useAllAmount: false,
+      };
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when toTransactionRaw", () => {
+    it("should return the raw transaction object", () => {
+      const tx = {
+        family: "aptos",
+        amount: BigNumber("0.5"),
+        options: {},
+        mode: "send",
+        recipient: "0xff00",
+        recipientDomain: {},
+        subAccountId: "0xff01",
+        useAllAmount: false,
+      } as Transaction;
+
+      const result = toTransactionRaw(tx);
+
+      const expected = {
+        family: "aptos",
+        mode: "send",
+        fees: null,
+        options: "{}",
+        amount: "0.5",
+        recipient: "0xff00",
+        useAllAmount: false,
+        subAccountId: "0xff01",
+        recipientDomain: {},
+      } as TransactionRaw;
+
+      expect(result).toEqual(expected);
+    });
+
+    it("should return the raw transaction object with fees", () => {
+      const tx = {
+        family: "aptos",
+        amount: BigNumber("0.5"),
+        options: {},
+        fees: BigNumber("0.1"),
+        mode: "send",
+        recipient: "0xff00",
+        recipientDomain: {},
+        subAccountId: "0xff01",
+        useAllAmount: false,
+      } as Transaction;
+
+      const result = toTransactionRaw(tx);
+
+      const expected = {
+        family: "aptos",
+        mode: "send",
+        fees: "0.1",
+        options: "{}",
+        amount: "0.5",
+        recipient: "0xff00",
+        useAllAmount: false,
+        subAccountId: "0xff01",
+        recipientDomain: {},
+      } as TransactionRaw;
+
+      expect(result).toEqual(expected);
+    });
+  });
+});

package/src/__tests__/errors.test.ts

@@ -0,0 +1,25 @@
+import {
+  SequenceNumberTooOldError,
+  SequenceNumberTooNewError,
+  TransactionExpiredError,
+} from "../errors";
+
+describe("APTOS errors", () => {
+  it("should create the SequenceNumberTooOldError error", () => {
+    const error = new SequenceNumberTooOldError();
+
+    expect(error).toBeInstanceOf(Error);
+  });
+
+  it("should create the SequenceNumberTooNewError error", () => {
+    const error = new SequenceNumberTooNewError();
+
+    expect(error).toBeInstanceOf(Error);
+  });
+
+  it("should create the TransactionExpiredError error", () => {
+    const error = new TransactionExpiredError();
+
+    expect(error).toBeInstanceOf(Error);
+  });
+});

package/src/__tests__/index.test.ts

@@ -0,0 +1,26 @@
+jest.mock("@ledgerhq/coin-framework/bridge/getAddressWrapper", () => jest.fn());
+jest.mock("@ledgerhq/coin-framework/signer", () => jest.fn());
+jest.mock("@ledgerhq/types-live", () => jest.fn());
+jest.mock("@ledgerhq/coin-framework/bridge/jsHelpers", () => ({
+  makeAccountBridgeReceive: jest.fn(),
+  makeScanAccounts: jest.fn(),
+  getSerializedAddressParameters: jest.fn(),
+  makeSync: jest.fn(),
+}));
+jest.mock("../signer", () => jest.fn());
+jest.mock("../types", () => jest.fn());
+jest.mock("../bridge/getTransactionStatus", () => jest.fn());
+jest.mock("../bridge/estimateMaxSpendable", () => jest.fn());
+jest.mock("../bridge/prepareTransaction", () => jest.fn());
+jest.mock("../bridge/createTransaction", () => jest.fn());
+jest.mock("../bridge/synchronisation", () => jest.fn());
+jest.mock("../bridge/signOperation", () => jest.fn());
+jest.mock("../bridge/broadcast", () => jest.fn());
+
+import { createBridges } from "../bridge";
+
+describe("APTOS index", () => {
+  it("should export a function createBridges", () => {
+    expect(typeof createBridges).toBe("function");
+  });
+});

package/src/__tests__/network/index.test.ts

@@ -0,0 +1,95 @@
+import { signTransaction } from "../../network";
+import { createFixtureAccount } from "../../bridge/bridge.fixture";
+import {
+  AccountAddress,
+  ChainId,
+  RawTransaction,
+  Serializable,
+  generateSigningMessageForTransaction,
+  generateSignedTransaction,
+} from "@aptos-labs/ts-sdk";
+
+jest.mock("@aptos-labs/ts-sdk", () => {
+  const originalModule = jest.requireActual("@aptos-labs/ts-sdk");
+  const partialMockedModule = Object.keys(originalModule).reduce(
+    (pre: { [key: string]: jest.Mock }, methodName) => {
+      pre[methodName] = jest.fn();
+      return pre;
+    },
+    {} as { [key: string]: jest.Mock },
+  );
+  return {
+    ...partialMockedModule,
+    // mock all except these
+    AccountAddress: originalModule.AccountAddress,
+    Hex: originalModule.Hex,
+  };
+});
+let mockedGenerateSigningMessageForTransaction: jest.Mocked<any>;
+let mockedGenerateSignedTransaction: jest.Mocked<any>;
+
+describe("signTransaction", () => {
+  beforeAll(() => {
+    mockedGenerateSigningMessageForTransaction = jest.mocked(generateSigningMessageForTransaction);
+    mockedGenerateSignedTransaction = jest.mocked(generateSignedTransaction);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("should throw an error", async () => {
+    mockedGenerateSigningMessageForTransaction.mockReturnValue("signingMessage");
+
+    const mockGenerateSignedTransactionSpy = jest.spyOn(
+      { generateSignedTransaction: mockedGenerateSignedTransaction },
+      "generateSignedTransaction",
+    );
+
+    const signerContext = jest.fn().mockImplementation(() => ({ signature: "0x7aa193705193f4" }));
+    const account = createFixtureAccount();
+    const deviceId = "nanoX";
+    const rawTxn = new RawTransaction(
+      new AccountAddress(Uint8Array.from(Buffer.from("thisaddressmustbe32byteslooooong"))),
+      BigInt(1),
+      "" as unknown as Serializable,
+      BigInt(100),
+      BigInt(50),
+      BigInt(1),
+      { chainId: 1 } as ChainId,
+    );
+
+    expect(signTransaction(signerContext, account, deviceId, rawTxn)).rejects.toThrow(
+      "Account must have a public signing key",
+    );
+
+    expect(mockGenerateSignedTransactionSpy).toHaveBeenCalledTimes(0);
+  });
+
+  it("should sign a transaction", async () => {
+    mockedGenerateSigningMessageForTransaction.mockReturnValue("signingMessage");
+
+    const mockGenerateSignedTransactionSpy = jest.spyOn(
+      { generateSignedTransaction: mockedGenerateSignedTransaction },
+      "generateSignedTransaction",
+    );
+
+    const signerContext = jest.fn().mockImplementation(() => ({ signature: "0x7aa193705193f4" }));
+    const account = createFixtureAccount();
+    account.xpub = "0xb69a68cc64f7aa193705193f4dd598320a0a74baf7e4b50c9980c5bd60a82390";
+    const deviceId = "nanoX";
+    const rawTxn = new RawTransaction(
+      AccountAddress.fromString(account.xpub),
+      BigInt(1),
+      "" as unknown as Serializable,
+      BigInt(100),
+      BigInt(50),
+      BigInt(1),
+      { chainId: 1 } as ChainId,
+    );
+
+    await signTransaction(signerContext, account, deviceId, rawTxn);
+
+    expect(mockGenerateSignedTransactionSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/signer/index.test.ts

@@ -0,0 +1,24 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import resolver from "../../signer";
+
+describe("aptos signer", () => {
+  test("getAddress", async () => {
+    const getAddress = resolver(
+      async () =>
+        ({
+          address: "address",
+          publicKey: Buffer.from("publicKey"),
+        }) as any,
+    );
+    const result = await getAddress("deviceId", {
+      path: "path",
+      currency: getCryptoCurrencyById("aptos"),
+      derivationMode: "",
+    });
+    expect(result).toMatchObject({
+      address: "address",
+      publicKey: "7075626c69634b6579",
+      path: "path",
+    });
+  });
+});

package/src/api/graphql/queries.ts

@@ -0,0 +1,53 @@
+import { gql } from "@apollo/client";
+
+export const GetDelegatedStakingActivities = gql`
+  query getDelegatedStakingActivities($delegatorAddress: String) {
+    delegated_staking_activities(
+      where: { delegator_address: { _eq: $delegatorAddress } }
+      order_by: { transaction_version: asc }
+    ) {
+      amount
+      delegator_address
+      event_index
+      event_type
+      pool_address
+      transaction_version
+    }
+  }
+`;
+export const GetAccountTransactionsData = gql`
+  query GetAccountTransactionsData($address: String, $limit: Int) {
+    address_version_from_move_resources(
+      where: { address: { _eq: $address } }
+      order_by: { transaction_version: desc }
+      limit: $limit
+    ) {
+      transaction_version
+      __typename
+    }
+  }
+`;
+export const GetAccountTransactionsDataGt = gql`
+  query GetAccountTransactionsDataGt($address: String, $limit: Int, $gt: bigint) {
+    address_version_from_move_resources(
+      where: { address: { _eq: $address }, transaction_version: { _gt: $gt } }
+      order_by: { transaction_version: desc }
+      limit: $limit
+    ) {
+      transaction_version
+      __typename
+    }
+  }
+`;
+export const GetAccountTransactionsDataLt = gql`
+  query GetAccountTransactionsDataLt($address: String, $limit: Int, $lt: bigint) {
+    address_version_from_move_resources(
+      where: { address: { _eq: $address }, transaction_version: { _lt: $lt } }
+      order_by: { transaction_version: desc }
+      limit: $limit
+    ) {
+      transaction_version
+      __typename
+    }
+  }
+`;

package/src/api/graphql/types.ts

@@ -0,0 +1,85 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  bigint: any;
+  jsonb: any;
+  numeric: any;
+  timestamp: any;
+  timestamptz: any;
+};
+
+export type GetAccountTransactionsDataQueryVariables = Exact<{
+  address?: InputMaybe<Scalars["String"]>;
+  limit?: InputMaybe<Scalars["Int"]>;
+}>;
+
+export type GetAccountTransactionsDataQuery = {
+  __typename?: "query_root";
+  address_version_from_move_resources: Array<{
+    __typename: "address_version_from_move_resources";
+    transaction_version?: any | null;
+  }>;
+};
+
+export type GetAccountTransactionsDataGtQueryVariables = Exact<{
+  address?: InputMaybe<Scalars["String"]>;
+  limit?: InputMaybe<Scalars["Int"]>;
+  gt?: InputMaybe<Scalars["bigint"]>;
+}>;
+
+export type GetAccountTransactionsDataGtQuery = {
+  __typename?: "query_root";
+  address_version_from_move_resources: Array<{
+    __typename: "address_version_from_move_resources";
+    transaction_version?: any | null;
+  }>;
+};
+
+export type GetAccountTransactionsDataLtQueryVariables = Exact<{
+  address?: InputMaybe<Scalars["String"]>;
+  limit?: InputMaybe<Scalars["Int"]>;
+  lt?: InputMaybe<Scalars["bigint"]>;
+}>;
+
+export type GetAccountTransactionsDataLtQuery = {
+  __typename?: "query_root";
+  address_version_from_move_resources: Array<{
+    __typename: "address_version_from_move_resources";
+    transaction_version?: any | null;
+  }>;
+};
+
+export type DelegatedStakingActivity = {
+  amount: number;
+  delegator_address: string;
+  event_index: number;
+  event_type: string;
+  pool_address: string;
+  transaction_version: bigint;
+};
+
+export type GetDelegatedStakingActivitiesQuery = {
+  delegated_staking_activities: Array<DelegatedStakingActivity>;
+};
+
+export type PartitionedDelegatedStakingActivities = Record<string, DelegatedStakingActivity[]>;
+
+export type StakePrincipals = {
+  activePrincipals: number;
+  pendingInactivePrincipals: number;
+};
+
+export type StakeDetails = {
+  active: number;
+  inactive: number;
+  pendingInactive: number;
+  canWithdrawPendingInactive: boolean;
+  poolAddress: string;
+};