import { adaptCoreOperationToLiveOperation, applyMemoToIntent, bigNumberToBigIntDeep, buildOptimisticOperation, cleanedOperation, extractBalance, extractBalances, findCryptoCurrencyByNetwork, transactionToIntent, } from "./utils"; import BigNumber from "bignumber.js"; import { Operation as CoreOperation, TransactionIntent } from "@ledgerhq/coin-framework/api/types"; import { Account } from "@ledgerhq/types-live"; import { GenericTransaction, OperationCommon } from "./types"; describe("Alpaca utils", () => { describe("applyMemoToIntent", () => { it("does not apply any memo", () => { const intent = applyMemoToIntent( {} as unknown as TransactionIntent, {} as GenericTransaction, ); expect(intent).toEqual({}); }); it.each([ [0, "0"], [1, "1"], ])("applies '%s' as the destination tag", (tag, expectedTag) => { const intent = applyMemoToIntent( {} as unknown as TransactionIntent, { tag } as GenericTransaction, ); expect(intent).toEqual({ memo: { type: "map", memos: new Map([["destinationTag", expectedTag]]) }, }); }); it("applies a custom memo type", () => { const intent = applyMemoToIntent( {} as unknown as TransactionIntent, { memoType: "memo-type", memoValue: "memo-value" } as GenericTransaction, ); expect(intent).toEqual({ memo: { type: "memo-type", value: "memo-value" }, }); }); }); describe("bigNumberToBigIntDeep", () => { it.each([ [undefined, undefined], [null, null], ["", ""], ["str", "str"], [0, 0], [1, 1], [true, true], [false, false], [new BigNumber(0), 0n], [new BigNumber(1), 1n], [[], []], [ ["str", 1], ["str", 1], ], [ ["str", BigNumber(1)], ["str", 1n], ], [ [new BigNumber(0), new BigNumber(1)], [0n, 1n], ], [{}, {}], [ { a: "str", b: 0, c: true }, { a: "str", b: 0, c: true }, ], [ { a: "str", b: new BigNumber(1), c: true }, { a: "str", b: 1n, c: true }, ], [ { a: "str", b: new BigNumber(1), c: { ca: new BigNumber(2), cb: 4 } }, { a: "str", b: 1n, c: { ca: 2n, cb: 4 } }, ], [ { a: "str", b: new BigNumber(1), c: { ca: new BigNumber(2), cb: null } }, { a: "str", b: 1n, c: { ca: 2n, cb: null } }, ], [ { a: "str", b: new BigNumber(1), c: { ca: new BigNumber(2), cb: undefined } }, { a: "str", b: 1n, c: { ca: 2n } }, ], ])("replaces BigNumbers with BigInts (%j)", (input, output) => { expect(bigNumberToBigIntDeep(input)).toStrictEqual(output); }); }); describe("buildOptimisticOperation", () => { it.each([ [ "coin", "changeTrust", {}, { parentType: "OPT_IN", subType: undefined, parentValue: new BigNumber(50), parentRecipient: "recipient-address", }, ], [ "coin", "delegate", {}, { parentType: "DELEGATE", subType: undefined, parentValue: new BigNumber(50), parentRecipient: "recipient-address", }, ], [ "coin", "stake", {}, { parentType: "DELEGATE", subType: undefined, parentValue: new BigNumber(50), parentRecipient: "recipient-address", }, ], [ "coin", "undelegate", {}, { parentType: "UNDELEGATE", subType: undefined, parentValue: new BigNumber(50), parentRecipient: "recipient-address", }, ], [ "coin", "unstake", {}, { parentType: "UNDELEGATE", subType: undefined, parentValue: new BigNumber(50), parentRecipient: "recipient-address", }, ], [ "coin", "send", {}, { parentType: "OUT", subType: undefined, parentValue: new BigNumber(50), parentRecipient: "recipient-address", }, ], [ "token", "changeTrust", { subAccountId: "sub-account-id" }, { parentType: "FEES", subType: "OPT_IN", parentValue: new BigNumber(12), parentRecipient: "contract-address", }, ], [ "token", "delegate", { subAccountId: "sub-account-id" }, { parentType: "FEES", subType: "DELEGATE", parentValue: new BigNumber(12), parentRecipient: "contract-address", }, ], [ "token", "stake", { subAccountId: "sub-account-id" }, { parentType: "FEES", subType: "DELEGATE", parentValue: new BigNumber(12), parentRecipient: "contract-address", }, ], [ "token", "undelegate", { subAccountId: "sub-account-id" }, { parentType: "FEES", subType: "UNDELEGATE", parentValue: new BigNumber(12), parentRecipient: "contract-address", }, ], [ "token", "unstake", { subAccountId: "sub-account-id" }, { parentType: "FEES", subType: "UNDELEGATE", parentValue: new BigNumber(12), parentRecipient: "contract-address", }, ], [ "token", "send", { subAccountId: "sub-account-id" }, { parentType: "FEES", subType: "OUT", parentValue: new BigNumber(12), parentRecipient: "contract-address", }, ], ])("builds an optimistic %s operation with %s mode", (_s, mode, params, expected) => { const operation = buildOptimisticOperation( { id: "parent-account-id", freshAddress: "account-address", subAccounts: [{ id: "sub-account-id", token: { contractAddress: "contract-address" } }], } as Account, { mode, amount: new BigNumber(50), fees: new BigNumber(12), recipient: "recipient-address", recipientDomain: { registry: "ens", domain: "recipient.eth", address: "recipient-address", type: "forward", }, ...params, } as GenericTransaction, 3n, ); expect(operation).toMatchObject({ id: `parent-account-id--${expected.parentType}`, transactionSequenceNumber: new BigNumber(3), type: expected.parentType, value: expected.parentValue, accountId: "parent-account-id", senders: ["account-address"], recipients: ["recipient-address"], fee: new BigNumber(12), blockHash: null, blockHeight: null, transactionRaw: { amount: expected.subType ? "0" : expected.parentValue.toFixed(), fees: "12", recipient: expected.parentRecipient, recipientDomain: { registry: "ens", domain: "recipient.eth", address: "recipient-address", type: "forward", }, }, ...(expected.subType ? { subOperations: [ { id: `sub-account-id--${expected.subType}`, transactionSequenceNumber: new BigNumber(3), accountId: "sub-account-id", type: expected.subType, senders: ["account-address"], recipients: ["recipient-address"], fee: new BigNumber(12), value: new BigNumber(50), blockHash: null, blockHeight: null, transactionRaw: { amount: "50", fees: "12", recipient: "recipient-address", }, }, ], } : {}), }); }); }); describe("cleanedOperation", () => { it("creates a cleaned version of an operation without mutating it", () => { const dirty = { id: "id", hash: "hash", senders: ["sender"], recipients: ["recipient"], extra: { assetAmount: 5, assetReference: "USDC", paginationToken: "pagination" }, } as unknown as OperationCommon; const clean = cleanedOperation(dirty); expect(clean).toEqual({ id: "id", hash: "hash", senders: ["sender"], recipients: ["recipient"], extra: { paginationToken: "pagination" }, }); expect(dirty).toEqual({ id: "id", hash: "hash", senders: ["sender"], recipients: ["recipient"], extra: { assetAmount: 5, assetReference: "USDC", paginationToken: "pagination" }, }); }); }); describe("transactionToIntent", () => { describe("type", () => { it("fallbacks to 'Payment' without a transaction mode", () => { expect( transactionToIntent( { currency: { name: "ethereum", units: [{}] } } as Account, { mode: undefined } as GenericTransaction, ), ).toMatchObject({ type: "Payment", }); }); it.each([ ["changeTrust", "changeTrust"], ["send", "send"], ["send-legacy", "send-legacy"], ["send-eip1559", "send-eip1559"], ["stake", "stake"], ["unstake", "unstake"], ["delegate", "stake"], ["undelegate", "unstake"], ])( "by default, associates '%s' transaction mode to '%s' intent type", (mode, expectedType) => { expect( transactionToIntent( { currency: { name: "ethereum", units: [{}] } } as Account, { mode } as GenericTransaction, ), ).toMatchObject({ type: expectedType, }); }, ); it("rejects other modes", () => { expect(() => transactionToIntent( { currency: { name: "ethereum", units: [{}] } } as Account, { mode: "any" as unknown } as GenericTransaction, ), ).toThrow("Unsupported transaction mode: any"); }); it("supersedes the logic with a custom function", () => { const computeIntentType = (transaction: GenericTransaction) => transaction.mode === "send" && transaction.type === 2 ? "send-eip1559" : "send-legacy"; expect( transactionToIntent( { currency: { name: "ethereum", units: [{}] } } as Account, { mode: "send", type: 2 } as GenericTransaction, computeIntentType, ), ).toMatchObject({ type: "send-eip1559", }); }); }); }); describe("findCryptoCurrencyByNetwork", () => { it("finds a crypto currency by id", () => { expect(findCryptoCurrencyByNetwork("ethereum")).toMatchObject({ id: "ethereum", family: "evm", }); }); it("takes currency remapping into account", () => { expect(findCryptoCurrencyByNetwork("ripple")).toMatchObject({ id: "ripple", family: "xrp", }); expect(findCryptoCurrencyByNetwork("xrp")).toMatchObject({ id: "ripple", family: "xrp", }); }); it("does not find non existing currencies", () => { expect(findCryptoCurrencyByNetwork("non_existing_currency")).toBeUndefined(); }); }); describe("extractBalances", () => { it("extracts native balance only", () => { expect( extractBalances({ spendableBalance: BigNumber(10), balance: BigNumber(10), } as unknown as Account), ).toEqual([{ value: 10n, locked: 0n, asset: { type: "native" } }]); expect( extractBalances({ spendableBalance: BigNumber(8), balance: BigNumber(10), } as unknown as Account), ).toEqual([{ value: 10n, locked: 2n, asset: { type: "native" } }]); }); it("extracts native and token balances", () => { expect( extractBalances( { spendableBalance: BigNumber(10), balance: BigNumber(10), subAccounts: [ { spendableBalance: BigNumber(11), balance: BigNumber(20), token: { tokenType: "erc20", contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", }, }, ], } as unknown as Account, token => ({ type: token.tokenType, assetReference: token.contractAddress, }), ), ).toEqual([ { value: 10n, locked: 0n, asset: { type: "native" } }, { asset: { assetReference: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", type: "erc20", }, locked: 9n, value: 20n, }, ]); }); }); describe("extractBalance", () => { it("extracts an existing balance", () => { expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({ value: 4n, asset: { type: "type1" }, }); }); it("generates an empty balance for a missing type", () => { expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type2")).toEqual({ value: 0n, asset: { type: "type2" }, }); }); }); jest.mock("@ledgerhq/ledger-wallet-framework/operation", () => ({ encodeOperationId: jest.fn((accountId, txHash, opType) => `${accountId}-${txHash}-${opType}`), })); describe("adaptCoreOperationToLiveOperation", () => { const accountId = "acc_123"; const baseOp: CoreOperation = { id: "op_123", asset: { type: "native" }, type: "OUT", value: BigInt(100), tx: { hash: "txhash123", fees: BigInt(10), block: { hash: "blockhash123", height: 123456, time: new Date("2025-08-29T12:00:00Z"), }, date: new Date("2025-08-29T12:00:00Z"), failed: false, }, senders: ["sender1"], recipients: ["recipient1"], }; it("does not include fees in non native asset value", () => { expect( adaptCoreOperationToLiveOperation("account", { id: "operation", asset: { type: "token", assetOwner: "owner", assetReference: "reference" }, type: "OUT", value: BigInt(100), tx: { hash: "hash", fees: BigInt(10), block: { hash: "block_hash", height: 123456, time: new Date("2025-08-29T12:00:00Z"), }, date: new Date("2025-08-29T12:00:00Z"), failed: false, }, senders: ["sender"], recipients: ["recipient"], }), ).toEqual({ id: "account-hash-OUT", hash: "hash", accountId: "account", type: "OUT", value: new BigNumber(100), // value only fee: new BigNumber(10), extra: { assetOwner: "owner", assetReference: "reference", }, blockHash: "block_hash", blockHeight: 123456, senders: ["sender"], recipients: ["recipient"], date: new Date("2025-08-29T12:00:00Z"), transactionSequenceNumber: undefined, hasFailed: false, }); }); it("adapts a basic OUT operation", () => { const result = adaptCoreOperationToLiveOperation(accountId, baseOp); expect(result).toEqual({ id: "acc_123-txhash123-OUT", hash: "txhash123", accountId, type: "OUT", value: new BigNumber(110), // value + fee fee: new BigNumber(10), blockHash: "blockhash123", blockHeight: 123456, senders: ["sender1"], recipients: ["recipient1"], date: new Date("2025-08-29T12:00:00Z"), transactionSequenceNumber: undefined, hasFailed: false, extra: {}, }); }); it.each([["FEES"], ["DELEGATE"], ["UNDELEGATE"]])( "handles %s operation where value = value + fees", operationType => { const op = { ...baseOp, type: operationType, value: BigInt(5), tx: { ...baseOp.tx, fees: BigInt(2) }, }; const result = adaptCoreOperationToLiveOperation(accountId, op); expect(result.value.toString()).toEqual("7"); }, ); it("handles non-FEES/OUT operation where value = value only", () => { const op = { ...baseOp, type: "IN", value: BigInt(50), tx: { ...baseOp.tx, fees: BigInt(2) }, }; const result = adaptCoreOperationToLiveOperation(accountId, op); expect(result.value.toString()).toEqual("50"); }); it("shows fees in value when transaction has failed", () => { const failedOp = { ...baseOp, type: "OUT", value: BigInt(100), tx: { ...baseOp.tx, fees: BigInt(25), failed: true }, }; const result = adaptCoreOperationToLiveOperation(accountId, failedOp); expect(result).toMatchObject({ hasFailed: true, value: new BigNumber(25), fee: new BigNumber(25), }); }); }); });