@ledgerhq/coin-tezos 6.5.0 → 6.6.0-nightly.0

package/src/logic/getBalance.ts

@@ -6,5 +6,5 @@ import api from "../network/tzkt";
  */
 export async function getBalance(address: string): Promise<bigint> {
   const apiAccount = await api.getAccountByAddress(address);
-  return apiAccount.type === "user" ? BigInt(apiAccount.balance) : BigInt(-1);
+  return apiAccount.type === "user" ? BigInt(apiAccount.balance) : -1n;
 }

package/src/logic/getStakes.test.ts

@@ -0,0 +1,145 @@
+import { createApi } from "../api/index";
+import tzktApi from "../network/tzkt";
+import coinConfig from "../config";
+
+describe("getStakes", () => {
+  const api = createApi({
+    baker: { url: "http://baker.example.com" },
+    explorer: { url: "http://tezos.explorer.com", maxTxQuery: 100 },
+    node: { url: "http://tezos.node.com" },
+    fees: {
+      minGasLimit: 600,
+      minRevealGasLimit: 300,
+      minStorageLimit: 0,
+      minFees: 500,
+      minEstimatedFees: 500,
+    },
+  });
+
+  const mockGetAccountByAddress = jest.spyOn(tzktApi, "getAccountByAddress");
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    coinConfig.setCoinConfig(() => ({
+      status: { type: "active" },
+      baker: { url: "http://baker.example.com" },
+      explorer: { url: "http://tezos.explorer.com", maxTxQuery: 100 },
+      node: { url: "http://tezos.node.com" },
+      fees: {
+        minGasLimit: 600,
+        minRevealGasLimit: 300,
+        minStorageLimit: 0,
+        minFees: 500,
+        minEstimatedFees: 500,
+      },
+    }));
+  });
+
+  describe("account types", () => {
+    it("should return empty stakes for non-delegated account", async () => {
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address: "tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq",
+        publicKey: "edpk...",
+        balance: 1000000,
+        revealed: true,
+        counter: 0,
+        delegationLevel: 0,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 0,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await api.getStakes("tz1WvvbEGpBXGeTVbLiR6DYBe1izmgiYuZbq");
+
+      expect(result.items).toEqual([]);
+    });
+
+    it("should return empty stakes for non user account", async () => {
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "empty",
+        address: "tz1EmptyAccount",
+        counter: 0,
+      });
+
+      const result = await api.getStakes("tz1EmptyAccount");
+
+      expect(result.items).toEqual([]);
+    });
+  });
+
+  describe("delegated accounts", () => {
+    it("should return stake for delegated account", async () => {
+      const address = "tz1TzrmTBSuiVHV2VfMnGRMYvTEPCP42oSM8";
+      const delegateAddress = "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx";
+      const balance = 5000000;
+
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address,
+        publicKey: "edpk...",
+        balance,
+        revealed: true,
+        counter: 0,
+        delegate: {
+          alias: "Test Delegate",
+          address: delegateAddress,
+          active: true,
+        },
+        delegationLevel: 100,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 10,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await api.getStakes(address);
+
+      expect(result.items).toEqual([
+        expect.objectContaining({
+          uid: address,
+          address,
+          delegate: delegateAddress,
+          state: "active",
+          asset: { type: "native" },
+          amount: BigInt(balance),
+        }),
+      ]);
+    });
+
+    it("should handle account with zero balance but delegation", async () => {
+      const address = "tz1ZeroBalanceAccount";
+      const delegateAddress = "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx";
+
+      mockGetAccountByAddress.mockResolvedValue({
+        type: "user",
+        address,
+        publicKey: "edpk...",
+        balance: 0,
+        revealed: true,
+        counter: 0,
+        delegate: {
+          alias: "Test Delegate",
+          address: delegateAddress,
+          active: true,
+        },
+        delegationLevel: 100,
+        delegationTime: "2021-01-01T00:00:00Z",
+        numTransactions: 0,
+        firstActivityTime: "2021-01-01T00:00:00Z",
+      });
+
+      const result = await api.getStakes(address);
+
+      expect(result.items).toHaveLength(1);
+      expect(result.items[0]).toMatchObject({
+        uid: address,
+        address,
+        delegate: delegateAddress,
+        state: "active",
+        asset: { type: "native" },
+        amount: BigInt(0),
+      });
+    });
+  });
+});

package/src/logic/getStakes.ts

@@ -0,0 +1,20 @@
+import type { Cursor, Page, Stake } from "@ledgerhq/coin-framework/api/types";
+import api from "../network/tzkt";
+
+export async function getStakes(address: string, _cursor?: Cursor): Promise<Page<Stake>> {
+  // tezos exposes a single staking position via delegation when a delegate is set
+  const accountInfo = await api.getAccountByAddress(address);
+  if (accountInfo.type !== "user" || !accountInfo.delegate?.address) return { items: [] };
+  return {
+    items: [
+      {
+        uid: address,
+        address,
+        delegate: accountInfo.delegate.address,
+        state: "active",
+        asset: { type: "native" },
+        amount: BigInt(accountInfo.balance ?? 0),
+      },
+    ],
+  };
+}

package/src/logic/index.ts

@@ -7,3 +7,5 @@ export { estimateFees } from "./estimateFees";
 export { getBalance } from "./getBalance";
 export { lastBlock } from "./lastBlock";
 export { listOperations } from "./listOperations";
+export { validateIntent } from "./validateIntent";
+export { getStakes } from "./getStakes";

package/src/logic/listOperations.test.ts

@@ -83,45 +83,50 @@ describe("listOperations", () => {
   };
 
   it.each([
-    ["undelegate", undelegate],
-    ["delegate", delegate],
-    ["transfer", transfer],
-  ])("should return %s operation with proper recipient list", async (_label, operation) => {
-    // Given
-    mockNetworkGetTransactions.mockResolvedValue([operation]);
-    // When
-    const [results] = await listOperations("any address", options);
-    // Then
-    expect(results).toEqual([
-      {
-        id: `${operation.hash}-${operation.id}`,
-        asset: { type: "native" },
-        details: {
-          counter: operation.counter,
-          gasLimit: operation.gasLimit,
-          storageLimit: operation.storageLimit,
-        },
-        senders: [someSenderAddress],
-        recipients: [someDestinationAddress],
-        tx: {
-          block: {
-            hash: operation.block,
-            height: operation.level,
-            time: new Date(operation.timestamp),
+    ["undelegate", undelegate, "DELEGATE", "DELEGATE"],
+    ["delegate", delegate, "UNDELEGATE", "UNDELEGATE"],
+    ["transfer", transfer, "OUT", undefined],
+  ])(
+    "should return %s operation with proper recipient list",
+    async (_label, operation, expectedType, expectedLedgerOpType) => {
+      // Given
+      mockNetworkGetTransactions.mockResolvedValue([operation]);
+      // When
+      const [results] = await listOperations("any address", options);
+      // Then
+      expect(results).toEqual([
+        {
+          id: `${operation.hash}-${operation.id}`,
+          asset: { type: "native" },
+          details: {
+            counter: operation.counter,
+            gasLimit: operation.gasLimit,
+            storageLimit: operation.storageLimit,
+            status: operation.status,
+            ledgerOpType: expectedLedgerOpType,
+          },
+          senders: [someSenderAddress],
+          recipients: [someDestinationAddress],
+          tx: {
+            block: {
+              hash: operation.block,
+              height: operation.level,
+              time: new Date(operation.timestamp),
+            },
+            date: new Date(operation.timestamp),
+            hash: operation.hash,
+            fees: BigInt(
+              (operation.allocationFee ?? 0) +
+                (operation.bakerFee ?? 0) +
+                (operation.storageFee ?? 0),
+            ),
           },
-          date: new Date(operation.timestamp),
-          hash: operation.hash,
-          fees: BigInt(
-            (operation.allocationFee ?? 0) +
-              (operation.bakerFee ?? 0) +
-              (operation.storageFee ?? 0),
-          ),
+          type: expectedType,
+          value: BigInt(operation.amount),
         },
-        type: operation.type,
-        value: BigInt(operation.amount),
-      },
-    ]);
-  });
+      ]);
+    },
+  );
 
   it.each([
     ["undelegate", undelegate],
@@ -142,23 +147,28 @@ describe("listOperations", () => {
   );
 
   it.each([
-    ["undelegate", undelegate],
-    ["delegate", delegate],
-    ["transfer", transfer],
-    ["reveal", reveal],
-  ])("should return %s operation with expected details", async (_label, operation) => {
-    // Given
-    mockNetworkGetTransactions.mockResolvedValue([operation]);
-    // When
-    const [results, _] = await listOperations("any address", options);
-    // Then
-    expect(results.length).toEqual(1);
-    expect(results[0].details).toEqual({
-      counter: 65214462,
-      gasLimit: 4,
-      storageLimit: 5,
-    });
-  });
+    ["undelegate", undelegate, "DELEGATE"],
+    ["delegate", delegate, "UNDELEGATE"],
+    ["transfer", transfer, undefined],
+    ["reveal", reveal, "REVEAL"],
+  ])(
+    "should return %s operation with expected details",
+    async (_label, operation, expectedLedgerOpType) => {
+      // Given
+      mockNetworkGetTransactions.mockResolvedValue([operation]);
+      // When
+      const [results, _] = await listOperations("any address", options);
+      // Then
+      expect(results.length).toEqual(1);
+      expect(results[0].details).toEqual({
+        counter: 65214462,
+        gasLimit: 4,
+        storageLimit: 5,
+        status: operation.status,
+        ledgerOpType: expectedLedgerOpType,
+      });
+    },
+  );
 
   it.each([
     { ...undelegate, newDelegate: null, prevDelegate: null },

package/src/logic/listOperations.ts

@@ -10,7 +10,6 @@ import {
   isAPITransactionType,
 } from "../network/types";
 import { Operation } from "@ledgerhq/coin-framework/api/types";
-// import { TezosAsset } from "../api/types";
 
 /**
  * Returns list of "Transfer", "Delegate" and "Undelegate" Operations associated to an account.
@@ -38,11 +37,15 @@ export async function listOperations(
     options = { ...options, lastId: JSON.parse(token) };
   }
   const operations = await tzkt.getAccountOperations(address, options);
-  const lastOperation = operations.slice(-1)[0];
+
+  // Apply limit after fetching since tzkt API might not respect the limit parameter
+  const limitedOperations = limit ? operations.slice(0, limit) : operations;
+
+  const lastOperation = limitedOperations.at(-1);
   // it's important to get the last id from the **unfiltered** operation list
   // otherwise we might miss operations
   const nextToken = lastOperation ? JSON.stringify(lastOperation?.id) : "";
-  const filteredOperations = operations
+  const filteredOperations = limitedOperations
     .filter(op => isAPITransactionType(op) || isAPIDelegationType(op) || isAPIRevealType(op))
     .reduce((acc, op) => acc.concat(convertOperation(address, op)), [] as Operation[]);
   const sortedOperations = filteredOperations.sort(
@@ -51,12 +54,29 @@ export async function listOperations(
   return [sortedOperations, nextToken];
 }
 
+/**
+ * Helper function to get the ledgerOpType for an operation
+ */
+function getLedgerOpType(
+  operation: APITransactionType | APIDelegationType | APIRevealType,
+  normalizedType: Operation["type"],
+): string | undefined {
+  if (isAPIDelegationType(operation)) {
+    return operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
+  } else if (isAPIRevealType(operation)) {
+    return "REVEAL";
+  } else if (normalizedType === "FEES") {
+    return "FEES";
+  }
+  return undefined;
+}
+
 // note that "initiator" of APITransactionType is never used in the conversion
 function convertOperation(
   address: string,
   operation: APITransactionType | APIDelegationType | APIRevealType,
 ): Operation {
-  const { hash, sender, type, id } = operation;
+  const { hash, sender, id } = operation;
 
   let targetAddress = undefined;
   if (isAPITransactionType(operation)) {
@@ -66,22 +86,48 @@ function convertOperation(
     targetAddress = operation?.newDelegate?.address || operation?.prevDelegate?.address;
   }
 
-  const recipients = [];
+  const recipients = targetAddress ? [targetAddress] : [];
   if (!targetAddress) {
     log("coin:tezos", "(logic/operations): No target address found for operation", operation);
-  } else {
-    recipients.push(targetAddress);
   }
 
   const senders = sender?.address ? [sender.address] : [];
 
-  const amount = isAPIRevealType(operation) ? BigInt(0) : BigInt(operation.amount);
+  const amount = isAPIRevealType(operation) ? 0n : BigInt(operation.amount);
 
   const fee =
     BigInt(operation.storageFee ?? 0) +
     BigInt(operation.bakerFee ?? 0) +
     BigInt(operation.allocationFee ?? 0);
 
+  // Determine operation type inline
+  let normalizedType: Operation["type"];
+  if (isAPIDelegationType(operation)) {
+    normalizedType = operation.newDelegate?.address ? "DELEGATE" : "UNDELEGATE";
+  } else if (isAPITransactionType(operation)) {
+    const isOut = sender?.address === address;
+    const isIn = targetAddress === address;
+
+    if ((isOut && isIn) || amount === 0n) {
+      normalizedType = "FEES";
+    } else if (isOut) {
+      normalizedType = "OUT";
+    } else if (isIn) {
+      normalizedType = "IN";
+    } else {
+      normalizedType = "OUT"; // fallback
+    }
+  } else if (isAPIRevealType(operation)) {
+    normalizedType = "REVEAL";
+  } else {
+    // fallback for unknown types
+    log("coin:tezos", "(logic/operations): Unknown operation type, defaulting to OUT");
+    normalizedType = "OUT";
+  }
+
+  // Tezos uses "applied" for every sucess operation (something else=failed )
+  const hasFailed = operation.status && operation.status !== "applied";
+
   return {
     id: `${hash ?? ""}-${id}`,
     asset: { type: "native" },
@@ -97,7 +143,7 @@ function convertOperation(
       },
       date: new Date(operation.timestamp),
     },
-    type: type,
+    type: normalizedType,
     value: amount,
     senders: senders,
     recipients: recipients,
@@ -105,6 +151,8 @@ function convertOperation(
       counter: operation.counter,
       gasLimit: operation.gasLimit,
       storageLimit: operation.storageLimit,
+      status: hasFailed ? "failed" : operation.status,
+      ledgerOpType: getLedgerOpType(operation, normalizedType),
     },
   };
 }