@ledgerhq/coin-vechain 2.9.1 → 2.9.2-nightly.0

package/src/bridge/transaction.test.ts

@@ -0,0 +1,440 @@
+import BigNumber from "bignumber.js";
+import {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+} from "./transaction";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon,
+} from "@ledgerhq/coin-framework/serialization";
+import { Transaction, TransactionRaw, TransactionStatus, TransactionStatusRaw } from "../types";
+import { Account } from "@ledgerhq/types-live";
+
+// Mock dependencies
+jest.mock("@ledgerhq/coin-framework/account/index");
+jest.mock("@ledgerhq/coin-framework/currencies/index");
+jest.mock("@ledgerhq/coin-framework/serialization");
+
+const mockedGetAccountCurrency = jest.mocked(getAccountCurrency);
+const mockedFormatCurrencyUnit = jest.mocked(formatCurrencyUnit);
+const mockedFromTransactionCommonRaw = jest.mocked(fromTransactionCommonRaw);
+const mockedFromTransactionStatusRawCommon = jest.mocked(fromTransactionStatusRawCommon);
+const mockedToTransactionCommonRaw = jest.mocked(toTransactionCommonRaw);
+const mockedToTransactionStatusRawCommon = jest.mocked(toTransactionStatusRawCommon);
+
+describe("transaction utilities", () => {
+  const mockAccount: Account = {
+    type: "Account",
+    id: "vechain:1:0x123:",
+    seedIdentifier: "seed123",
+    derivationMode: "" as any,
+    index: 0,
+    freshAddress: "0x742d35Cc6634C0532925a3b8D0B251d8c1743eC4",
+    freshAddressPath: "44'/818'/0'/0/0",
+    used: true,
+    balance: new BigNumber("5000000000000000000"),
+    spendableBalance: new BigNumber("5000000000000000000"),
+    creationDate: new Date("2022-01-01"),
+    blockHeight: 12345,
+    currency: {
+      name: "VeChain",
+      units: [{ name: "VET", code: "VET", magnitude: 18 }],
+    } as any,
+    operationsCount: 10,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date("2022-01-01"),
+    balanceHistoryCache: { HOUR: {}, DAY: {}, WEEK: {} } as any,
+    swapHistory: [],
+    subAccounts: [],
+  };
+
+  const mockTransaction: Transaction = {
+    family: "vechain",
+    recipient: "0x456789012345678901234567890123456789abcd",
+    amount: new BigNumber("1000000000000000000"), // 1 VET
+    estimatedFees: "210000000000000000",
+    useAllAmount: false,
+    body: {
+      chainTag: 74,
+      blockRef: "0x00000000000b2bce",
+      expiration: 18,
+      clauses: [],
+      maxFeePerGas: 10000000000000,
+      maxPriorityFeePerGas: 1000000000000,
+      gas: 21000,
+      dependsOn: null,
+      nonce: "0x12345678",
+    },
+  } as Transaction;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedGetAccountCurrency.mockReturnValue(mockAccount.currency);
+    mockedFormatCurrencyUnit.mockReturnValue("1 VET");
+  });
+
+  describe("formatTransaction", () => {
+    it("should format transaction with amount", () => {
+      const result = formatTransaction(mockTransaction, mockAccount);
+
+      expect(result).toBe("SEND  1 VET TO 0x456789012345678901234567890123456789abcd");
+      expect(mockedGetAccountCurrency).toHaveBeenCalledWith(mockAccount);
+      expect(mockedFormatCurrencyUnit).toHaveBeenCalledWith(
+        mockAccount.currency.units[0],
+        mockTransaction.amount,
+        {
+          showCode: true,
+          disableRounding: true,
+        },
+      );
+    });
+
+    it("should format transaction with useAllAmount", () => {
+      const useAllAmountTransaction = { ...mockTransaction, useAllAmount: true };
+
+      const result = formatTransaction(useAllAmountTransaction, mockAccount);
+
+      expect(result).toBe("SEND MAX TO 0x456789012345678901234567890123456789abcd");
+      expect(mockedFormatCurrencyUnit).not.toHaveBeenCalled();
+    });
+
+    it("should format transaction with zero amount", () => {
+      const zeroAmountTransaction = {
+        ...mockTransaction,
+        amount: new BigNumber("0"),
+        useAllAmount: false,
+      };
+
+      const result = formatTransaction(zeroAmountTransaction, mockAccount);
+
+      expect(result).toBe("SEND  TO 0x456789012345678901234567890123456789abcd");
+      expect(mockedFormatCurrencyUnit).not.toHaveBeenCalled();
+    });
+
+    it("should handle different recipients", () => {
+      const differentRecipientTx = {
+        ...mockTransaction,
+        recipient: "0x999888777666555444333222111000aaabbbcccd",
+      };
+
+      const result = formatTransaction(differentRecipientTx, mockAccount);
+
+      expect(result).toBe("SEND  1 VET TO 0x999888777666555444333222111000aaabbbcccd");
+    });
+
+    it("should handle different formatted amounts", () => {
+      mockedFormatCurrencyUnit.mockReturnValue("2.5 VET");
+
+      const result = formatTransaction(mockTransaction, mockAccount);
+
+      expect(result).toBe("SEND  2.5 VET TO 0x456789012345678901234567890123456789abcd");
+    });
+
+    it("should handle empty recipient", () => {
+      const emptyRecipientTx = { ...mockTransaction, recipient: "" };
+
+      const result = formatTransaction(emptyRecipientTx, mockAccount);
+
+      expect(result).toBe("SEND  1 VET TO ");
+    });
+
+    it("should handle very large amounts", () => {
+      const largeAmountTx = {
+        ...mockTransaction,
+        amount: new BigNumber("1000000000000000000000000"),
+      };
+      mockedFormatCurrencyUnit.mockReturnValue("1000000 VET");
+
+      const result = formatTransaction(largeAmountTx, mockAccount);
+
+      expect(result).toBe("SEND  1000000 VET TO 0x456789012345678901234567890123456789abcd");
+    });
+  });
+
+  describe("fromTransactionRaw", () => {
+    const mockTransactionRaw: TransactionRaw = {
+      family: "vechain",
+      recipient: "0x456789012345678901234567890123456789abcd",
+      amount: "1000000000000000000",
+      estimatedFees: "210000000000000000",
+      body: {
+        chainTag: 74,
+        blockRef: "0x00000000000b2bce",
+        expiration: 18,
+        clauses: [],
+        maxFeePerGas: 10000000000000,
+        maxPriorityFeePerGas: 1000000000000,
+        gas: 21000,
+        dependsOn: null,
+        nonce: "0x12345678",
+      },
+    } as TransactionRaw;
+
+    const mockCommonData = {
+      mode: "send" as any,
+      useAllAmount: false,
+      amount: new BigNumber("1000000000000000000"),
+      recipient: "0x456789012345678901234567890123456789abcd",
+    };
+
+    it("should deserialize transaction from raw", () => {
+      mockedFromTransactionCommonRaw.mockReturnValue(mockCommonData);
+
+      const result = fromTransactionRaw(mockTransactionRaw);
+
+      expect(result).toEqual({
+        ...mockTransactionRaw,
+        ...mockCommonData,
+      });
+      expect(mockedFromTransactionCommonRaw).toHaveBeenCalledWith(mockTransactionRaw);
+    });
+
+    it("should merge raw data with common data", () => {
+      const extendedCommonData = {
+        mode: "send" as any,
+        useAllAmount: true,
+        amount: new BigNumber("1000000000000000000"),
+        recipient: "0x456789012345678901234567890123456789abcd",
+        subAccountId: "vechain:1:0x123:+vtho",
+      };
+      mockedFromTransactionCommonRaw.mockReturnValue(extendedCommonData);
+
+      const result = fromTransactionRaw(mockTransactionRaw);
+
+      expect(result).toEqual({
+        ...mockTransactionRaw,
+        ...extendedCommonData,
+      });
+    });
+  });
+
+  describe("toTransactionRaw", () => {
+    const mockCommonRawData = {
+      mode: "send" as any,
+      useAllAmount: false,
+      amount: "1000000000000000000",
+      recipient: "0x456789012345678901234567890123456789abcd",
+    };
+
+    it("should serialize transaction to raw", () => {
+      mockedToTransactionCommonRaw.mockReturnValue(mockCommonRawData);
+
+      const result = toTransactionRaw(mockTransaction);
+
+      expect(result).toEqual({
+        ...mockTransaction,
+        ...mockCommonRawData,
+      });
+      expect(mockedToTransactionCommonRaw).toHaveBeenCalledWith(mockTransaction);
+    });
+
+    it("should merge transaction data with common raw data", () => {
+      const extendedCommonRawData = {
+        mode: "send" as any,
+        useAllAmount: true,
+        amount: "1000000000000000000",
+        recipient: "0x456789012345678901234567890123456789abcd",
+        subAccountId: "vechain:1:0x123:+vtho",
+      };
+      mockedToTransactionCommonRaw.mockReturnValue(extendedCommonRawData);
+
+      const result = toTransactionRaw(mockTransaction);
+
+      expect(result).toEqual({
+        ...mockTransaction,
+        ...extendedCommonRawData,
+      });
+    });
+  });
+
+  describe("fromTransactionStatusRaw", () => {
+    const mockTransactionStatusRaw: TransactionStatusRaw = {
+      errors: {},
+      warnings: {},
+      estimatedFees: "210000000000000000",
+      amount: "1000000000000000000",
+      totalSpent: "1000000000000000000",
+    } as TransactionStatusRaw;
+
+    const mockCommonStatusData = {
+      errors: {},
+      warnings: {},
+      estimatedFees: new BigNumber("210000000000000000"),
+      amount: new BigNumber("1000000000000000000"),
+      totalSpent: new BigNumber("1000000000000000000"),
+      txid: "0x123",
+    };
+
+    it("should deserialize transaction status from raw", () => {
+      mockedFromTransactionStatusRawCommon.mockReturnValue(mockCommonStatusData);
+
+      const result = fromTransactionStatusRaw(mockTransactionStatusRaw);
+
+      expect(result).toEqual({
+        ...mockTransactionStatusRaw,
+        ...mockCommonStatusData,
+      });
+      expect(mockedFromTransactionStatusRawCommon).toHaveBeenCalledWith(mockTransactionStatusRaw);
+    });
+
+    it("should merge raw status data with common data", () => {
+      const extendedCommonStatusData = {
+        errors: {},
+        warnings: {},
+        estimatedFees: new BigNumber("210000000000000000"),
+        amount: new BigNumber("1000000000000000000"),
+        totalSpent: new BigNumber("1000000000000000000"),
+        txid: "0x456",
+        gasLimit: new BigNumber("21000"),
+      };
+      mockedFromTransactionStatusRawCommon.mockReturnValue(extendedCommonStatusData);
+
+      const result = fromTransactionStatusRaw(mockTransactionStatusRaw);
+
+      expect(result).toEqual({
+        ...mockTransactionStatusRaw,
+        ...extendedCommonStatusData,
+      });
+    });
+  });
+
+  describe("toTransactionStatusRaw", () => {
+    const mockTransactionStatus: TransactionStatus = {
+      errors: {},
+      warnings: {},
+      estimatedFees: new BigNumber("210000000000000000"),
+      amount: new BigNumber("1000000000000000000"),
+      totalSpent: new BigNumber("1000000000000000000"),
+    } as TransactionStatus;
+
+    const mockCommonStatusRawData = {
+      errors: {},
+      warnings: {},
+      estimatedFees: "210000000000000000",
+      amount: "1000000000000000000",
+      totalSpent: "1000000000000000000",
+      txid: "0x789",
+    };
+
+    it("should serialize transaction status to raw", () => {
+      mockedToTransactionStatusRawCommon.mockReturnValue(mockCommonStatusRawData);
+
+      const result = toTransactionStatusRaw(mockTransactionStatus);
+
+      expect(result).toEqual({
+        ...mockTransactionStatus,
+        ...mockCommonStatusRawData,
+      });
+      expect(mockedToTransactionStatusRawCommon).toHaveBeenCalledWith(mockTransactionStatus);
+    });
+
+    it("should merge transaction status data with common raw data", () => {
+      const extendedCommonStatusRawData = {
+        errors: {},
+        warnings: {},
+        estimatedFees: "210000000000000000",
+        amount: "1000000000000000000",
+        totalSpent: "1000000000000000000",
+        txid: "0xabc",
+        gasLimit: "21000",
+      };
+      mockedToTransactionStatusRawCommon.mockReturnValue(extendedCommonStatusRawData);
+
+      const result = toTransactionStatusRaw(mockTransactionStatus);
+
+      expect(result).toEqual({
+        ...mockTransactionStatus,
+        ...extendedCommonStatusRawData,
+      });
+    });
+  });
+
+  describe("default export", () => {
+    it("should export all functions in default object", () => {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const defaultExport = require("./transaction").default;
+
+      expect(defaultExport).toEqual({
+        formatTransaction,
+        formatTransactionStatus: expect.any(Function), // This is imported from coin-framework
+        fromTransactionRaw,
+        toTransactionRaw,
+        fromTransactionStatusRaw,
+        toTransactionStatusRaw,
+      });
+    });
+  });
+
+  describe("integration with currency formatting", () => {
+    it("should call formatCurrencyUnit with correct parameters", () => {
+      const customAmount = new BigNumber("2500000000000000000"); // 2.5 VET
+      const customTransaction = { ...mockTransaction, amount: customAmount };
+
+      formatTransaction(customTransaction, mockAccount);
+
+      expect(mockedFormatCurrencyUnit).toHaveBeenCalledWith(
+        mockAccount.currency.units[0],
+        customAmount,
+        {
+          showCode: true,
+          disableRounding: true,
+        },
+      );
+    });
+
+    it("should use the first currency unit", () => {
+      const multiUnitCurrency = {
+        ...mockAccount.currency,
+        units: [
+          { name: "VET", code: "VET", magnitude: 18 },
+          { name: "Wei", code: "wei", magnitude: 0 },
+        ],
+      };
+      const customAccount = { ...mockAccount, currency: multiUnitCurrency };
+      mockedGetAccountCurrency.mockReturnValue(multiUnitCurrency);
+
+      formatTransaction(mockTransaction, customAccount);
+
+      expect(mockedFormatCurrencyUnit).toHaveBeenCalledWith(
+        multiUnitCurrency.units[0], // Should use the first unit
+        mockTransaction.amount,
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle getAccountCurrency errors", () => {
+      mockedGetAccountCurrency.mockImplementation(() => {
+        throw new Error("Currency not found");
+      });
+
+      expect(() => formatTransaction(mockTransaction, mockAccount)).toThrow("Currency not found");
+    });
+
+    it("should handle formatCurrencyUnit errors", () => {
+      mockedFormatCurrencyUnit.mockImplementation(() => {
+        throw new Error("Formatting error");
+      });
+
+      expect(() => formatTransaction(mockTransaction, mockAccount)).toThrow("Formatting error");
+    });
+
+    it("should handle fromTransactionCommonRaw errors", () => {
+      const mockTransactionRaw = {} as TransactionRaw;
+      mockedFromTransactionCommonRaw.mockImplementation(() => {
+        throw new Error("Deserialization error");
+      });
+
+      expect(() => fromTransactionRaw(mockTransactionRaw)).toThrow("Deserialization error");
+    });
+  });
+});

package/src/common-logic/calculateClauses.test.ts

@@ -0,0 +1,186 @@
+import BigNumber from "bignumber.js";
+import { ABIContract, VIP180_ABI, VTHO_ADDRESS } from "@vechain/sdk-core";
+import { calculateClausesVtho, calculateClausesVet } from "./calculateClauses";
+
+describe("calculateClauses", () => {
+  const testRecipient = "0x1234567890123456789012345678901234567890";
+  const testAmount = new BigNumber("1000000000000000000"); // 1 VET/VTHO in wei
+
+  describe("calculateClausesVtho", () => {
+    it("should create correct VTHO transfer clause", async () => {
+      const clauses = await calculateClausesVtho(testRecipient, testAmount);
+
+      expect(clauses).toHaveLength(1);
+      expect(clauses[0]).toMatchObject({
+        to: VTHO_ADDRESS,
+        value: 0,
+      });
+      expect(clauses[0].data).toMatch(/^0x/);
+      expect(clauses[0].data).not.toBe("0x");
+    });
+
+    it("should encode transfer function call in data field", async () => {
+      const clauses = await calculateClausesVtho(testRecipient, testAmount);
+
+      // The data should be the encoded function call for transfer(address,uint256)
+      const expectedData = ABIContract.ofAbi(VIP180_ABI)
+        .encodeFunctionInput("transfer", [testRecipient, testAmount.toFixed()])
+        .toString();
+
+      expect(clauses[0].data).toBe(expectedData);
+    });
+
+    it("should handle different amounts correctly", async () => {
+      const amounts = [
+        new BigNumber("1"), // 1 wei
+        new BigNumber("1000"), // 1000 wei
+        new BigNumber("1000000000000000000"), // 1 token
+        new BigNumber("999999999999999999999999"), // large amount
+      ];
+
+      for (const amount of amounts) {
+        const clauses = await calculateClausesVtho(testRecipient, amount);
+
+        expect(clauses).toHaveLength(1);
+        expect(clauses[0].to).toBe(VTHO_ADDRESS);
+        expect(clauses[0].value).toBe(0);
+
+        // Verify the amount is encoded correctly in the data
+        const expectedData = ABIContract.ofAbi(VIP180_ABI)
+          .encodeFunctionInput("transfer", [testRecipient, amount.toFixed()])
+          .toString();
+        expect(clauses[0].data).toBe(expectedData);
+      }
+    });
+
+    it("should handle different recipients correctly", async () => {
+      const recipients = [
+        "0x1234567890123456789012345678901234567890",
+        "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+        "0x0000000000000000000000000000000000000000",
+        "0xffffffffffffffffffffffffffffffffffffffff",
+      ];
+
+      for (const recipient of recipients) {
+        const clauses = await calculateClausesVtho(recipient, testAmount);
+
+        expect(clauses).toHaveLength(1);
+        expect(clauses[0].to).toBe(VTHO_ADDRESS);
+
+        // Verify the recipient is encoded correctly in the data
+        const expectedData = ABIContract.ofAbi(VIP180_ABI)
+          .encodeFunctionInput("transfer", [recipient, testAmount.toFixed()])
+          .toString();
+        expect(clauses[0].data).toBe(expectedData);
+      }
+    });
+
+    it("should handle integer amounts correctly", async () => {
+      const integerAmount = new BigNumber("1500000000000000000"); // 1.5 * 10^18 as integer
+      const clauses = await calculateClausesVtho(testRecipient, integerAmount);
+
+      const expectedData = ABIContract.ofAbi(VIP180_ABI)
+        .encodeFunctionInput("transfer", [testRecipient, integerAmount.toFixed()])
+        .toString();
+
+      expect(clauses[0].data).toBe(expectedData);
+    });
+  });
+
+  describe("calculateClausesVet", () => {
+    it("should create correct VET transfer clause", async () => {
+      const clauses = await calculateClausesVet(testRecipient, testAmount);
+
+      expect(clauses).toHaveLength(1);
+      expect(clauses[0]).toMatchObject({
+        to: testRecipient,
+        value: `0x${testAmount.toString(16)}`,
+        data: "0x",
+      });
+    });
+
+    it("should convert amount to hex correctly", async () => {
+      const testCases = [
+        { amount: new BigNumber("1"), expectedHex: "0x1" },
+        { amount: new BigNumber("255"), expectedHex: "0xff" },
+        { amount: new BigNumber("256"), expectedHex: "0x100" },
+        { amount: new BigNumber("1000000000000000000"), expectedHex: "0xde0b6b3a7640000" },
+      ];
+
+      for (const testCase of testCases) {
+        const clauses = await calculateClausesVet(testRecipient, testCase.amount);
+
+        expect(clauses[0].value).toBe(testCase.expectedHex);
+        expect(clauses[0].to).toBe(testRecipient);
+        expect(clauses[0].data).toBe("0x");
+      }
+    });
+
+    it("should handle different recipients correctly", async () => {
+      const recipients = [
+        "0x1234567890123456789012345678901234567890",
+        "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+        "0x0000000000000000000000000000000000000000",
+        "0xffffffffffffffffffffffffffffffffffffffff",
+      ];
+
+      for (const recipient of recipients) {
+        const clauses = await calculateClausesVet(recipient, testAmount);
+
+        expect(clauses).toHaveLength(1);
+        expect(clauses[0].to).toBe(recipient);
+        expect(clauses[0].value).toBe(`0x${testAmount.toString(16)}`);
+        expect(clauses[0].data).toBe("0x");
+      }
+    });
+
+    it("should handle zero amount", async () => {
+      const zeroAmount = new BigNumber("0");
+      const clauses = await calculateClausesVet(testRecipient, zeroAmount);
+
+      expect(clauses[0].value).toBe("0x0");
+      expect(clauses[0].to).toBe(testRecipient);
+    });
+
+    it("should handle very large amounts", async () => {
+      const largeAmount = new BigNumber("999999999999999999999999");
+      const clauses = await calculateClausesVet(testRecipient, largeAmount);
+
+      expect(clauses[0].value).toBe(`0x${largeAmount.toString(16)}`);
+      expect(clauses[0].to).toBe(testRecipient);
+    });
+
+    it("should maintain data field as empty hex", async () => {
+      const clauses = await calculateClausesVet(testRecipient, testAmount);
+
+      expect(clauses[0].data).toBe("0x");
+    });
+  });
+
+  describe("return value structure", () => {
+    it("should always return an array of clauses", async () => {
+      const vthoResult = await calculateClausesVtho(testRecipient, testAmount);
+      const vetResult = await calculateClausesVet(testRecipient, testAmount);
+
+      expect(Array.isArray(vthoResult)).toBe(true);
+      expect(Array.isArray(vetResult)).toBe(true);
+      expect(vthoResult).toHaveLength(1);
+      expect(vetResult).toHaveLength(1);
+    });
+
+    it("should return clauses with required VechainSDKTransactionClause structure", async () => {
+      const vthoResult = await calculateClausesVtho(testRecipient, testAmount);
+      const vetResult = await calculateClausesVet(testRecipient, testAmount);
+
+      // Check VTHO clause structure
+      expect(vthoResult[0]).toHaveProperty("to");
+      expect(vthoResult[0]).toHaveProperty("value");
+      expect(vthoResult[0]).toHaveProperty("data");
+
+      // Check VET clause structure
+      expect(vetResult[0]).toHaveProperty("to");
+      expect(vetResult[0]).toHaveProperty("value");
+      expect(vetResult[0]).toHaveProperty("data");
+    });
+  });
+});

package/src/common-logic/calculateClauses.ts

@@ -0,0 +1,44 @@
+import BigNumber from "bignumber.js";
+import { VechainSDKTransactionClause } from "../types";
+import { ABIContract, VIP180_ABI, VTHO_ADDRESS } from "@vechain/sdk-core";
+
+export const calculateClausesVtho = async (
+  recipient: string,
+  amount: BigNumber,
+): Promise<VechainSDKTransactionClause[]> => {
+  const clauses: VechainSDKTransactionClause[] = [];
+
+  // Get the existing clause or create a blank one
+  const updatedClause: VechainSDKTransactionClause = {
+    to: VTHO_ADDRESS,
+    value: 0,
+    data: "0x",
+  };
+  updatedClause.data = ABIContract.ofAbi(VIP180_ABI)
+    .encodeFunctionInput("transfer", [recipient, amount.toFixed()])
+    .toString();
+
+  clauses.push(updatedClause);
+  return clauses;
+};
+
+export const calculateClausesVet = async (
+  recipient: string,
+  amount: BigNumber,
+): Promise<VechainSDKTransactionClause[]> => {
+  const clauses: VechainSDKTransactionClause[] = [];
+
+  // Get the existing clause or create a blank one
+  const updatedClause: VechainSDKTransactionClause = {
+    to: null,
+    value: 0,
+    data: "0x",
+  };
+
+  updatedClause.value = `0x${amount.toString(16)}`;
+  updatedClause.to = recipient;
+
+  clauses.push(updatedClause);
+
+  return clauses;
+};