@ledgerhq/coin-sui 0.16.0 → 0.17.0-nightly.1

package/src/api/index.integration.test.ts

@@ -93,6 +93,24 @@ describe("Sui Api", () => {
     });
   });
 
+  describe("listOperations (staking)", () => {
+    let txs: Operation[];
+
+    beforeAll(async () => {
+      [txs] = await module.listOperations(
+        "0x13d73cab19d2cf14e39289b122ed93fb0f9edd00e4c829e0cefb1f0611c54a8f",
+        { minHeight: 0, order: "asc" },
+      );
+    });
+
+    it("should map undelegate operations when it's not the first move call", async () => {
+      const tx1 = txs.find(t => t.id === "4UtCqCH3oNEdaprZR9UjaMGg6HgLn3V3q3FEcvs5vieM");
+      expect(tx1?.type).toBe("UNDELEGATE");
+      const tx2 = txs.find(t => t.id === "JEGnHCx2mtpDin216kbUBXm7V5rdMSPSUmgYbP3yxTEf");
+      expect(tx2?.type).toBe("UNDELEGATE");
+    });
+  });
+
   describe("listOperations", () => {
     let txs: Operation[];
 
@@ -182,13 +200,68 @@ describe("Sui Api", () => {
 
   describe("getBlock", () => {
     test("getBlock should get block by id or sequence number", async () => {
-      const block = await module.getBlock(164167623);
-      expect(block.info.height).toEqual(164167623);
-      expect(block.info.hash).toEqual("3Q4zW4ieWnNgKLEq6kvVfP35PX2tBDUJERTWYyyz4eyS");
-      expect(block.info.time).toEqual(new Date(1751696298663));
-      expect(block.info.parent?.height).toEqual(164167622);
-      expect(block.info.parent?.hash).toEqual("6VKtVnpxstb968SzSrgYJ7zy5LXgFB6PnNHSJsT8Wr4E");
-      expect(block.transactions.length).toEqual(19);
+      const block = await module.getBlock(195177985);
+      expect(block.info.height).toEqual(195177985);
+      expect(block.info.hash).toEqual("AzoHwjcCXkeiWoBVyWwZcE171zjxochFmcr9eQoNQyYn");
+      expect(block.info.time).toEqual(new Date(1759138080141));
+      expect(block.info.parent?.height).toEqual(195177984);
+      expect(block.info.parent?.hash).toEqual("A15NYkPDyKLZS4Swik7AY2mnLxwFET4kyNV6ChZ8tVJP");
+      expect(block.transactions.length).toEqual(12);
+      const tx = block.transactions[9];
+      const senderOp = tx.operations[0];
+      const receipientOp = tx.operations[1];
+      expect(tx.hash).toEqual("J3ddkv4TRqr4LviCbA3JyJCji5Kg5BcaBTkd6nMY5WXN");
+      expect(tx.operations.length).toEqual(2);
+      expect(senderOp.address).toEqual(
+        "0x2c814ceb68d1cb7168207b16754b1cf57e735685c4e5d87c4f50906edcc57c1c",
+      );
+      expect(senderOp.peer).toEqual(
+        "0xb37b298c9164c28c8aaf989a49416e3c323b67bc2b96a54501b524419ebb4ead",
+      );
+      expect(senderOp.amount).toEqual(BigInt(-5));
+      expect(receipientOp.address).toEqual(
+        "0xb37b298c9164c28c8aaf989a49416e3c323b67bc2b96a54501b524419ebb4ead",
+      );
+      expect(receipientOp.peer).toEqual(
+        "0x2c814ceb68d1cb7168207b16754b1cf57e735685c4e5d87c4f50906edcc57c1c",
+      );
+      expect(receipientOp.amount).toEqual(BigInt(5));
+    });
+  });
+
+  describe("getValidators", () => {
+    it("returns at least a hundred validators with expected fields", async () => {
+      const page = await module.getValidators();
+
+      expect(Array.isArray(page.items)).toBeTruthy();
+      expect(page.items.length).toBeGreaterThanOrEqual(100);
+
+      const v = page.items[0];
+      expect(v).toHaveProperty("address");
+      expect(v).toHaveProperty("name");
+      expect(v).toHaveProperty("description");
+      expect(v).toHaveProperty("url");
+      expect(v).toHaveProperty("logo");
+      expect(v).toHaveProperty("balance");
+      expect(v).toHaveProperty("commissionRate");
+      expect(v).toHaveProperty("apy");
+
+      // values should not be empty
+      expect(typeof v.address).toBe("string");
+      expect(v.address.length).toBeGreaterThan(0);
+      expect(typeof v.name).toBe("string");
+      expect(v.name.length).toBeGreaterThan(0);
+      expect(typeof v.description).toBe("string");
+      expect((v.description as string).length).toBeGreaterThan(0);
+      expect(typeof v.url).toBe("string");
+      expect((v.url as string).length).toBeGreaterThan(0);
+      expect(typeof v.logo).toBe("string");
+      expect((v.logo as string).length).toBeGreaterThan(0);
+      expect(typeof v.balance === "bigint").toBeTruthy();
+      expect(v.balance as bigint).toBeGreaterThanOrEqual(0n);
+      expect(typeof v.commissionRate).toBe("string");
+      expect((v.commissionRate as string).length).toBeGreaterThan(0);
+      expect(typeof v.apy).toBe("number");
     });
   });
 

package/src/api/index.ts

@@ -11,6 +11,7 @@ import {
   craftTransaction,
   getStakes,
   getRewards,
+  getValidators as logicGetValidators,
 } from "../logic";
 import {
   AlpacaApi,
@@ -42,6 +43,7 @@ export function createApi(config: SuiConfig): AlpacaApi {
     listOperations: logicListOperations,
     getStakes,
     getRewards,
+    getValidators: logicGetValidators,
   };
 }
 

package/src/logic/estimateFees.test.ts

@@ -33,14 +33,17 @@ describe("estimateFees", () => {
 
     const result = await estimateFees(transactionIntent);
 
-    expect(suiAPI.paymentInfo).toHaveBeenCalledWith(transactionIntent.sender, {
-      recipient: transactionIntent.recipient,
-      amount: BigNumber(transactionIntent.amount.toString()),
-      coinType: "0x2::sui::SUI",
-      errors: {},
-      family: "sui",
-      mode: "send",
-    });
+    expect(suiAPI.paymentInfo).toHaveBeenCalledWith(
+      transactionIntent.sender,
+      expect.objectContaining({
+        recipient: transactionIntent.recipient,
+        amount: BigNumber(transactionIntent.amount.toString()),
+        coinType: "0x2::sui::SUI",
+        errors: {},
+        family: "sui",
+        mode: "send",
+      }),
+    );
     expect(result).toBe(BigInt(mockGasBudget));
   });
 
@@ -61,14 +64,17 @@ describe("estimateFees", () => {
 
     const result = await estimateFees(transactionIntent);
 
-    expect(suiAPI.paymentInfo).toHaveBeenCalledWith(transactionIntent.sender, {
-      recipient: transactionIntent.recipient,
-      amount: BigNumber("0"),
-      coinType: "0x2::sui::SUI",
-      errors: {},
-      family: "sui",
-      mode: "send",
-    });
+    expect(suiAPI.paymentInfo).toHaveBeenCalledWith(
+      transactionIntent.sender,
+      expect.objectContaining({
+        recipient: transactionIntent.recipient,
+        amount: BigNumber("0"),
+        coinType: "0x2::sui::SUI",
+        errors: {},
+        family: "sui",
+        mode: "send",
+      }),
+    );
     expect(result).toBe(BigInt(mockGasBudget));
   });
 });

package/src/logic/estimateFees.ts

@@ -9,7 +9,11 @@ export async function estimateFees({
   sender,
   asset,
   type,
-}: TransactionIntent): Promise<bigint> {
+  ...extra
+}: TransactionIntent & {
+  useAllAmount?: boolean;
+  stakedSuiId?: string;
+}): Promise<bigint> {
   let coinType = DEFAULT_COIN_TYPE;
   if (asset.type === "token" && asset.assetReference) {
     coinType = asset.assetReference;
@@ -35,6 +39,7 @@ export async function estimateFees({
     amount: BigNumber(amount.toString()),
     errors: {},
     coinType,
+    ...extra,
   });
   return BigInt(gasBudget);
 }

package/src/logic/getValidators.test.ts

@@ -0,0 +1,92 @@
+import * as network from "../network";
+import { getValidators } from "./getValidators";
+
+type NetworkValidator = {
+  suiAddress: string;
+  name: string;
+  description: string;
+  projectUrl: string;
+  imageUrl: string;
+  stakingPoolSuiBalance: string;
+  commissionRate: string;
+  apy: number;
+};
+
+jest.mock("../network", () => ({
+  getValidators: jest.fn(),
+}));
+
+const mockedGetValidators = jest.mocked(network.getValidators);
+
+describe("logic/getValidators", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("maps network validators to generic Validator and returns single page", async () => {
+    const networkValidators: NetworkValidator[] = [
+      {
+        suiAddress: "0xabc",
+        name: "Validator A",
+        description: "desc",
+        projectUrl: "https://example.com",
+        imageUrl: "https://example.com/logo.png",
+        stakingPoolSuiBalance: "1234567890",
+        commissionRate: "0.1",
+        apy: 0.08,
+      },
+      {
+        suiAddress: "0xdef",
+        name: "Validator B",
+        description: "",
+        projectUrl: "",
+        imageUrl: "",
+        stakingPoolSuiBalance: "0",
+        commissionRate: "0",
+        apy: 0,
+      },
+    ];
+
+    mockedGetValidators.mockResolvedValueOnce(
+      networkValidators as unknown as ReturnType<typeof network.getValidators>,
+    );
+
+    const page = await getValidators();
+
+    expect(page.next).toBeUndefined();
+    expect(page.items).toHaveLength(2);
+
+    const [a, b] = page.items;
+    expect(a).toEqual({
+      address: "0xabc",
+      name: "Validator A",
+      description: "desc",
+      url: "https://example.com",
+      logo: "https://example.com/logo.png",
+      balance: BigInt("1234567890"),
+      commissionRate: "0.1",
+      apy: 0.08,
+    });
+
+    expect(b).toEqual({
+      address: "0xdef",
+      name: "Validator B",
+      description: "",
+      url: "",
+      logo: "",
+      balance: 0n,
+      commissionRate: "0",
+      apy: 0,
+    });
+  });
+
+  it("handles empty network response", async () => {
+    mockedGetValidators.mockResolvedValueOnce(
+      [] as unknown as ReturnType<typeof network.getValidators>,
+    );
+
+    const page = await getValidators();
+    expect(page.items).toEqual([]);
+    expect(page.next).toBeUndefined();
+  });
+});

package/src/logic/getValidators.ts

@@ -0,0 +1,23 @@
+import { type Page, type Validator } from "@ledgerhq/coin-framework/api/index";
+import { getValidators as getValidatorsFromNetwork } from "../network";
+
+export async function getValidators(_cursor?: string): Promise<Page<Validator>> {
+  const validators = await getValidatorsFromNetwork();
+
+  const items: Validator[] = validators.map(v => ({
+    address: v.suiAddress,
+    name: v.name,
+    description: v.description,
+    url: v.projectUrl,
+    logo: v.imageUrl,
+    balance: BigInt(v.stakingPoolSuiBalance),
+    commissionRate: v.commissionRate,
+    apy: v.apy,
+  }));
+
+  return {
+    items,
+    // there is no underlying pagination, so undefined token
+    next: undefined,
+  };
+}

package/src/logic/index.ts

@@ -8,3 +8,4 @@ export { getBlock, getBlockInfo } from "./getBlock";
 export { listOperations } from "./listOperations";
 export { getStakes, getRewards } from "./staking";
 export { canStake } from "./stake";
+export { getValidators } from "./getValidators";

package/src/network/index.ts

@@ -9,6 +9,7 @@ import {
   createTransaction,
   executeTransactionBlock,
   getStakes,
+  getValidators,
 } from "./sdk";
 
 export {
@@ -22,6 +23,7 @@ export {
   createTransaction,
   executeTransactionBlock,
   getStakes,
+  getValidators,
 };
 
 export default {
@@ -35,4 +37,5 @@ export default {
   createTransaction,
   executeTransactionBlock,
   getStakes,
+  getValidators,
 };

package/src/network/sdk.test.ts

@@ -3,8 +3,12 @@ import coinConfig from "../config";
 
 import { BigNumber } from "bignumber.js";
 import { SuiClient } from "@mysten/sui/client";
-import type { TransactionBlockData, SuiTransactionBlockResponse } from "@mysten/sui/client";
-import assert from "assert";
+import type {
+  TransactionBlockData,
+  SuiTransactionBlockResponse,
+  SuiTransactionBlockKind,
+} from "@mysten/sui/client";
+import assert, { fail } from "assert";
 
 // Mock SUI client for tests
 jest.mock("@mysten/sui/client", () => {
@@ -232,7 +236,6 @@ function mockStakingTx(address: string, amount: string) {
 
 // amount must be a positive number
 function mockUnstakingTx(address: string, amount: string) {
-  assert(new BigNumber(amount).gte(0), "amount must be a positive number");
   return {
     digest: "undelegate_tx_digest_456",
     transaction: {
@@ -609,17 +612,48 @@ describe("SDK Functions", () => {
 
 describe("Staking Operations", () => {
   describe("Operation Type Detection", () => {
+    const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
     test("getOperationType should return DELEGATE for staking transaction", () => {
-      const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
       expect(sdk.getOperationType(address, mockStakingTx(address, "-1000000000"))).toBe("DELEGATE");
     });
 
     test("getOperationType should return UNDELEGATE for unstaking transaction", () => {
-      const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
       expect(sdk.getOperationType(address, mockUnstakingTx(address, "1000000000"))).toBe(
         "UNDELEGATE",
       );
     });
+
+    function prependOtherMoveCall(block: SuiTransactionBlockKind) {
+      if (block?.kind === "ProgrammableTransaction") {
+        block.transactions.unshift({
+          MoveCall: {
+            function: "other_function",
+            module: "module",
+            package: "package",
+          },
+        });
+      }
+    }
+
+    test("getOperationType should return UNDELEGATE when it's not the first MoveCall ", () => {
+      const tx = mockUnstakingTx(address, "1000");
+      if (tx.transaction) {
+        prependOtherMoveCall(tx.transaction.data.transaction);
+        expect(sdk.getOperationType(address, tx)).toBe("UNDELEGATE");
+      } else {
+        fail("can't prepare fixture");
+      }
+    });
+
+    test("getOperationType should return DELEGATE when it's not the first MoveCall ", () => {
+      const tx = mockStakingTx(address, "-1000");
+      if (tx.transaction) {
+        prependOtherMoveCall(tx.transaction.data.transaction);
+        expect(sdk.getOperationType(address, tx)).toBe("DELEGATE");
+      } else {
+        fail("can't prepare fixture");
+      }
+    });
   });
 
   describe("Operation Amount Calculation", () => {
@@ -661,17 +695,20 @@ describe("Staking Operations", () => {
     }
 
     test("alpaca getOperationAmount should calculate staking amount", () =>
-      expect(alpacaOperationAmount(mockStakingTx(address, "-1000000000"))).toEqual(
+      expect(alpacaOperationAmount(mockStakingTx(address, "-1001050000"))).toEqual(
         new BigNumber("1000000000"),
       ));
 
+    // 1000 unstaked & 1050000 gas fees = -1049000 balance change
     test("alpaca getOperationAmount should calculate unstaking amount of 1000", () =>
-      expect(alpacaOperationAmount(mockUnstakingTx(address, "1000"))).toEqual(
+      expect(alpacaOperationAmount(mockUnstakingTx(address, "-1049000"))).toEqual(
         new BigNumber("1000"),
       ));
 
     test("alpaca getOperationAmount should calculate unstaking amount of 0", () =>
-      expect(alpacaOperationAmount(mockUnstakingTx(address, "0"))).toEqual(new BigNumber("0")));
+      expect(alpacaOperationAmount(mockUnstakingTx(address, "-1050000"))).toEqual(
+        new BigNumber("0"),
+      ));
 
     test("alpaca getOperationAmount should calculate amount correctly for SUI", () =>
       expect(alpacaOperationAmount(mockTransaction)).toEqual(new BigNumber("9998990120")));
@@ -824,7 +861,7 @@ describe("Staking Operations", () => {
     test("transactionToOp should map staking transaction correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
 
-      const operation = sdk.alpacaTransactionToOp(address, mockStakingTx(address, "-1000000000"));
+      const operation = sdk.alpacaTransactionToOp(address, mockStakingTx(address, "-1001050000"));
 
       expect(operation.id).toEqual("delegate_tx_digest_123");
       expect(operation.type).toEqual("DELEGATE");
@@ -838,7 +875,7 @@ describe("Staking Operations", () => {
     test("transactionToOp should map unstaking transaction correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
 
-      const operation = sdk.alpacaTransactionToOp(address, mockUnstakingTx(address, "1000000000"));
+      const operation = sdk.alpacaTransactionToOp(address, mockUnstakingTx(address, "998950000"));
 
       expect(operation.id).toEqual("undelegate_tx_digest_456");
       expect(operation.type).toEqual("UNDELEGATE");
@@ -1737,17 +1774,22 @@ describe("filterOperations", () => {
   describe("conversion methods", () => {
     test("toBlockOperation should map native transfers correctly", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            AddressOwner: "0x65449f57946938c84c5127",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              AddressOwner: "0x65449f57946938c84c5127",
+            },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "transfer",
           address: "0x65449f57946938c84c5127",
+          peer: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
           amount: -10000000000n,
           asset: { type: "native" },
         },
@@ -1756,68 +1798,89 @@ describe("filterOperations", () => {
 
     test("toBlockOperation should ignore transfers from shared owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            Shared: {
-              initial_shared_version: "0",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              Shared: {
+                initial_shared_version: "0",
+              },
             },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should ignore transfers from object owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            ObjectOwner: "test",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              ObjectOwner: "test",
+            },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should ignore transfers from immutable owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: "Immutable",
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: "Immutable",
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
+          },
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should ignore transfers from consensus owner", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            ConsensusAddressOwner: {
-              owner: "test",
-              start_version: "1",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              ConsensusAddressOwner: {
+                owner: "test",
+                start_version: "1",
+              },
             },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
           },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([]);
     });
 
     test("toBlockOperation should map token transfers correctly", () => {
       expect(
-        sdk.toBlockOperation(mockTransaction, {
-          owner: {
-            AddressOwner: "0x65449f57946938c84c5127",
+        sdk.toBlockOperation(
+          mockTransaction,
+          {
+            owner: {
+              AddressOwner: "0x65449f57946938c84c5127",
+            },
+            coinType: "0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC",
+            amount: "8824",
           },
-          coinType: "0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC",
-          amount: "8824",
-        }),
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "transfer",
           address: "0x65449f57946938c84c5127",
+          peer: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
           amount: 8824n,
           asset: {
             type: "token",
@@ -1830,18 +1893,22 @@ describe("filterOperations", () => {
     test("toBlockOperation should map staking operations correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
       expect(
-        sdk.toBlockOperation(mockStakingTx(address, "-1000000000"), {
-          owner: { AddressOwner: address },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "-10000000000",
-        }),
+        sdk.toBlockOperation(
+          mockStakingTx(address, "-1000000000"),
+          {
+            owner: { AddressOwner: address },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "-10000000000",
+          },
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "other",
           operationType: "DELEGATE",
           address: address,
           asset: { type: "native" },
-          amount: 10000000000n,
+          amount: -10000000000n,
         },
       ]);
     });
@@ -1849,11 +1916,15 @@ describe("filterOperations", () => {
     test("toBlockOperation should map unstaking operations correctly", () => {
       const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
       expect(
-        sdk.toBlockOperation(mockUnstakingTx(address, "1000000000"), {
-          owner: { AddressOwner: address },
-          coinType: sdk.DEFAULT_COIN_TYPE,
-          amount: "10000000000",
-        }),
+        sdk.toBlockOperation(
+          mockUnstakingTx(address, "1000000000"),
+          {
+            owner: { AddressOwner: address },
+            coinType: sdk.DEFAULT_COIN_TYPE,
+            amount: "10000000000",
+          },
+          BigNumber(0),
+        ),
       ).toEqual([
         {
           type: "other",
@@ -1909,18 +1980,21 @@ describe("filterOperations", () => {
         operations: [
           {
             address: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
-            amount: -10000000000n,
+            peer: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+            amount: -9998990120n,
             asset: { type: "native" },
             type: "transfer",
           },
           {
             address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+            peer: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
             amount: 9998990120n,
             asset: { type: "native" },
             type: "transfer",
           },
           {
             address: "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0",
+            peer: "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24",
             amount: 500000n,
             asset: { type: "token", assetReference: "0x123::test::TOKEN" },
             type: "transfer",