@sundaeswap/sprinkles 0.6.1 → 0.7.0

package/src/Sprinkle/__tests__/wallet-transaction-actions.test.ts

@@ -0,0 +1,695 @@
+import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { Type } from "@sinclair/typebox";
+import { ActionError } from "../actions/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+// Mock wallet/UTxO data factories
+function makeAddress(bech32 = "addr_test1qz...mock") {
+  return { toBech32: () => bech32 };
+}
+
+function makeAssetId(policyId: string, assetName: string) {
+  return `${policyId}${assetName}`;
+}
+
+function makeUtxo(opts: {
+  txHash: string;
+  index: number;
+  lovelace: bigint;
+  tokens?: Array<{ policyId: string; assetName: string; quantity: bigint }>;
+}) {
+  const tokenEntries = (opts.tokens ?? []).map((t) => [
+    makeAssetId(t.policyId, t.assetName),
+    t.quantity,
+  ]);
+
+  return {
+    input: () => ({
+      transactionId: () => ({ toString: () => opts.txHash }),
+      index: () => BigInt(opts.index),
+    }),
+    output: () => ({
+      amount: () => ({
+        coin: () => opts.lovelace,
+        multiasset: () =>
+          tokenEntries.length > 0
+            ? { entries: () => tokenEntries }
+            : undefined,
+      }),
+    }),
+  };
+}
+
+// Controllable mock state
+let mockBlaze: any = {};
+let mockIsHot = true;
+let mockBlazeError: Error | null = null;
+
+mock.module("../actions/builtin/blaze-helper.js", () => ({
+  getBlazeFromContext: async () => {
+    if (mockBlazeError) throw mockBlazeError;
+    return mockBlaze;
+  },
+  isHotWallet: () => mockIsHot,
+}));
+
+// Mock Core.AssetId static methods used by wallet/transaction actions
+mock.module("@blaze-cardano/sdk", () => ({
+  Core: {
+    AssetId: {
+      getPolicyId: (assetId: string) => assetId.slice(0, 56),
+      getAssetName: (assetId: string) => assetId.slice(56),
+    },
+    Transaction: {
+      fromCbor: (cbor: string) => mockTxFromCbor(cbor),
+    },
+    TxCBOR: (s: string) => s,
+  },
+  Blaze: class {},
+  HotWallet: class {},
+}));
+
+// Controllable mock transaction from CBOR
+// These mock objects are compatible with the real countSignatures/getRequiredSigners
+// from tx-dialog.ts, so we don't need to mock that module (which would leak globally).
+let mockTxFromCbor: (cbor: string) => any = () => ({
+  body: () => ({
+    hash: () => ({ toString: () => "abc123txhash" }),
+    inputs: () => ({
+      values: () => [
+        {
+          transactionId: () => ({ toString: () => "input-tx-hash-1" }),
+          index: () => 0n,
+        },
+      ],
+    }),
+    outputs: () => [
+      {
+        address: () => ({ toBech32: () => "addr_test1output..." }),
+        amount: () => ({
+          coin: () => 2_000_000n,
+          multiasset: () => undefined,
+        }),
+      },
+    ],
+    fee: () => 200_000n,
+    requiredSigners: () => null,
+  }),
+  witnessSet: () => ({
+    vkeys: () => null,
+  }),
+  toCbor: () => "signed-cbor-hex",
+});
+
+// Now import the actions (after mocks are set up)
+const { getWalletAddress, getWalletBalance, getWalletUtxos } = await import(
+  "../actions/builtin/wallet-actions.js"
+);
+const {
+  signTransaction,
+  submitTransaction,
+  signAndSubmit,
+  decodeTransaction,
+} = await import("../actions/builtin/transaction-actions.js");
+
+// Minimal context factory
+function makeContext(settingsOverrides: Record<string, unknown> = {}) {
+  return {
+    sprinkle: {} as any,
+    settings: {
+      network: "preview",
+      provider: { type: "blockfrost", apiKey: "test" },
+      wallet: { type: "hot", mnemonic: "test words" },
+      ...settingsOverrides,
+    } as any,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Wallet Actions
+// ---------------------------------------------------------------------------
+
+describe("get-wallet-address", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+    mockIsHot = true;
+  });
+
+  test("returns bech32 address and network", async () => {
+    mockBlaze = {
+      wallet: {
+        getChangeAddress: async () => makeAddress("addr_test1qzabc123"),
+      },
+    };
+    const ctx = makeContext();
+    const result = await getWalletAddress.execute({}, ctx);
+    expect(result.address).toBe("addr_test1qzabc123");
+    expect(result.network).toBe("preview");
+  });
+
+  test("returns 'unknown' network when not in settings", async () => {
+    mockBlaze = {
+      wallet: {
+        getChangeAddress: async () => makeAddress("addr1mainnet"),
+      },
+    };
+    const ctx = makeContext({ network: undefined });
+    const result = await getWalletAddress.execute({}, ctx);
+    expect(result.network).toBe("unknown");
+  });
+
+  test("throws WALLET_NOT_CONFIGURED when getBlazeFromContext fails", async () => {
+    mockBlazeError = new ActionError("Missing settings", "WALLET_NOT_CONFIGURED", {
+      missingFields: ["wallet"],
+    });
+    const ctx = makeContext();
+    await expect(getWalletAddress.execute({}, ctx)).rejects.toMatchObject({
+      code: "WALLET_NOT_CONFIGURED",
+    });
+  });
+
+  test("throws NO_ADDRESS when wallet returns no address", async () => {
+    mockBlaze = {
+      wallet: {
+        getChangeAddress: async () => {
+          throw new Error("no address available");
+        },
+      },
+    };
+    const ctx = makeContext();
+    await expect(getWalletAddress.execute({}, ctx)).rejects.toMatchObject({
+      code: "NO_ADDRESS",
+    });
+  });
+
+  test("has correct metadata", () => {
+    expect(getWalletAddress.name).toBe("get-wallet-address");
+    expect(getWalletAddress.category).toBe("wallet");
+    expect(getWalletAddress.inputSchema).toBeDefined();
+    expect(getWalletAddress.outputSchema).toBeDefined();
+  });
+});
+
+describe("get-wallet-balance", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+  });
+
+  test("returns lovelace, ada, and empty tokens for ADA-only wallet", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => [
+          makeUtxo({ txHash: "tx1", index: 0, lovelace: 5_000_000n }),
+          makeUtxo({ txHash: "tx2", index: 1, lovelace: 3_000_000n }),
+        ],
+      },
+    };
+    const result = await getWalletBalance.execute({}, makeContext());
+    expect(result.lovelace).toBe("8000000");
+    expect(result.ada).toBe("8.000000");
+    expect(result.tokens).toEqual([]);
+  });
+
+  test("aggregates tokens across UTxOs", async () => {
+    const policyId = "a".repeat(56);
+    const assetName = "token1";
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => [
+          makeUtxo({
+            txHash: "tx1",
+            index: 0,
+            lovelace: 2_000_000n,
+            tokens: [{ policyId, assetName, quantity: 100n }],
+          }),
+          makeUtxo({
+            txHash: "tx2",
+            index: 0,
+            lovelace: 1_000_000n,
+            tokens: [{ policyId, assetName, quantity: 50n }],
+          }),
+        ],
+      },
+    };
+    const result = await getWalletBalance.execute({}, makeContext());
+    expect(result.lovelace).toBe("3000000");
+    expect(result.tokens).toHaveLength(1);
+    expect(result.tokens[0].quantity).toBe("150");
+    expect(result.tokens[0].policyId).toBe(policyId);
+  });
+
+  test("handles fractional ADA correctly", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => [
+          makeUtxo({ txHash: "tx1", index: 0, lovelace: 1_500_123n }),
+        ],
+      },
+    };
+    const result = await getWalletBalance.execute({}, makeContext());
+    expect(result.ada).toBe("1.500123");
+  });
+
+  test("handles zero balance", async () => {
+    mockBlaze = {
+      wallet: { getUnspentOutputs: async () => [] },
+    };
+    const result = await getWalletBalance.execute({}, makeContext());
+    expect(result.lovelace).toBe("0");
+    expect(result.ada).toBe("0.000000");
+    expect(result.tokens).toEqual([]);
+  });
+
+  test("throws PROVIDER_ERROR on UTxO fetch failure", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => {
+          throw new Error("connection timeout");
+        },
+      },
+    };
+    await expect(getWalletBalance.execute({}, makeContext())).rejects.toMatchObject({
+      code: "PROVIDER_ERROR",
+    });
+  });
+});
+
+describe("get-wallet-utxos", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+  });
+
+  test("returns UTxOs with correct structure", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => [
+          makeUtxo({ txHash: "txhash1", index: 0, lovelace: 5_000_000n }),
+          makeUtxo({ txHash: "txhash2", index: 1, lovelace: 3_000_000n }),
+        ],
+      },
+    };
+    const result = await getWalletUtxos.execute({}, makeContext());
+    expect(result.total).toBe(2);
+    expect(result.utxos).toHaveLength(2);
+    expect(result.utxos[0].txHash).toBe("txhash1");
+    expect(result.utxos[0].outputIndex).toBe(0);
+    expect(result.utxos[0].lovelace).toBe("5000000");
+    expect(result.utxos[0].tokens).toEqual([]);
+  });
+
+  test("respects limit parameter", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () =>
+          Array.from({ length: 10 }, (_, i) =>
+            makeUtxo({ txHash: `tx${i}`, index: 0, lovelace: 1_000_000n }),
+          ),
+      },
+    };
+    const result = await getWalletUtxos.execute({ limit: 3 }, makeContext());
+    expect(result.utxos).toHaveLength(3);
+    expect(result.total).toBe(10);
+  });
+
+  test("defaults to limit of 100", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () =>
+          Array.from({ length: 150 }, (_, i) =>
+            makeUtxo({ txHash: `tx${i}`, index: 0, lovelace: 1_000_000n }),
+          ),
+      },
+    };
+    const result = await getWalletUtxos.execute({}, makeContext());
+    expect(result.utxos).toHaveLength(100);
+    expect(result.total).toBe(150);
+  });
+
+  test("includes tokens on UTxOs", async () => {
+    const policyId = "b".repeat(56);
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => [
+          makeUtxo({
+            txHash: "tx1",
+            index: 0,
+            lovelace: 2_000_000n,
+            tokens: [{ policyId, assetName: "mytoken", quantity: 42n }],
+          }),
+        ],
+      },
+    };
+    const result = await getWalletUtxos.execute({}, makeContext());
+    expect(result.utxos[0].tokens).toHaveLength(1);
+    expect(result.utxos[0].tokens[0].quantity).toBe("42");
+  });
+
+  test("throws PROVIDER_ERROR on fetch failure", async () => {
+    mockBlaze = {
+      wallet: {
+        getUnspentOutputs: async () => {
+          throw new Error("provider down");
+        },
+      },
+    };
+    await expect(getWalletUtxos.execute({}, makeContext())).rejects.toMatchObject({
+      code: "PROVIDER_ERROR",
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Transaction Actions
+// ---------------------------------------------------------------------------
+
+describe("sign-transaction", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+    mockIsHot = true;
+  });
+
+  test("signs a transaction and returns signed CBOR, hash, and signature count", async () => {
+    mockBlaze = {
+      wallet: {},
+      signTransaction: async () => ({
+        toCbor: () => "signed-tx-cbor",
+        body: () => ({
+          hash: () => ({ toString: () => "signed-tx-hash" }),
+        }),
+        witnessSet: () => ({ vkeys: () => ({ size: () => 1 }) }),
+      }),
+    };
+    const result = await signTransaction.execute(
+      { txCbor: "valid-cbor" },
+      makeContext(),
+    );
+    expect(result.signedTxCbor).toBe("signed-tx-cbor");
+    expect(result.txHash).toBe("signed-tx-hash");
+    expect(result.signatureCount).toBe(1);
+  });
+
+  test("throws COLD_WALLET for cold wallets", async () => {
+    mockIsHot = false;
+    mockBlaze = { wallet: {} };
+    await expect(
+      signTransaction.execute({ txCbor: "some-cbor" }, makeContext()),
+    ).rejects.toMatchObject({ code: "COLD_WALLET" });
+  });
+
+  test("throws INVALID_CBOR for bad CBOR input", async () => {
+    mockTxFromCbor = () => {
+      throw new Error("invalid cbor");
+    };
+    mockBlaze = { wallet: {} };
+    await expect(
+      signTransaction.execute({ txCbor: "bad-cbor" }, makeContext()),
+    ).rejects.toMatchObject({ code: "INVALID_CBOR" });
+
+    // Restore default mock
+    mockTxFromCbor = () => ({
+      body: () => ({
+        hash: () => ({ toString: () => "abc123txhash" }),
+        inputs: () => ({ values: () => [] }),
+        outputs: () => [],
+        fee: () => 200_000n,
+        requiredSigners: () => null,
+      }),
+      witnessSet: () => ({ vkeys: () => null }),
+      toCbor: () => "signed-cbor-hex",
+    });
+  });
+
+  test("throws SIGN_ERROR when signing fails", async () => {
+    mockBlaze = {
+      wallet: {},
+      signTransaction: async () => {
+        throw new Error("hardware wallet disconnected");
+      },
+    };
+    await expect(
+      signTransaction.execute({ txCbor: "valid-cbor" }, makeContext()),
+    ).rejects.toMatchObject({ code: "SIGN_ERROR" });
+  });
+
+  test("has correct metadata", () => {
+    expect(signTransaction.name).toBe("sign-transaction");
+    expect(signTransaction.category).toBe("wallet");
+  });
+});
+
+describe("submit-transaction", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+  });
+
+  test("submits a transaction and returns hash", async () => {
+    mockBlaze = {
+      wallet: {},
+      submitTransaction: async () => ({
+        toString: () => "submitted-tx-hash",
+      }),
+    };
+    const result = await submitTransaction.execute(
+      { txCbor: "valid-signed-cbor" },
+      makeContext(),
+    );
+    expect(result.txHash).toBe("submitted-tx-hash");
+    expect(result.submitted).toBe(true);
+  });
+
+  test("throws SUBMISSION_ERROR on failure", async () => {
+    mockBlaze = {
+      wallet: {},
+      submitTransaction: async () => {
+        throw new Error("tx already submitted");
+      },
+    };
+    await expect(
+      submitTransaction.execute({ txCbor: "some-cbor" }, makeContext()),
+    ).rejects.toMatchObject({ code: "SUBMISSION_ERROR" });
+  });
+
+  test("has correct metadata", () => {
+    expect(submitTransaction.name).toBe("submit-transaction");
+    expect(submitTransaction.category).toBe("wallet");
+  });
+});
+
+describe("sign-and-submit", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+    mockIsHot = true;
+  });
+
+  test("signs and submits without waiting for confirmation", async () => {
+    mockBlaze = {
+      wallet: {},
+      signTransaction: async () => ({
+        toCbor: () => "signed-cbor",
+        body: () => ({
+          hash: () => ({ toString: () => "tx-hash" }),
+        }),
+        witnessSet: () => ({ vkeys: () => ({ size: () => 1 }) }),
+      }),
+      submitTransaction: async () => ({
+        toString: () => "tx-hash",
+      }),
+    };
+    const result = await signAndSubmit.execute(
+      { txCbor: "valid-cbor", waitForConfirmation: false },
+      makeContext(),
+    );
+    expect(result.txHash).toBe("tx-hash");
+    expect(result.submitted).toBe(true);
+    expect(result.signedTxCbor).toBe("signed-cbor");
+    expect(result.confirmed).toBeUndefined();
+  });
+
+  test("throws COLD_WALLET for cold wallets", async () => {
+    mockIsHot = false;
+    mockBlaze = { wallet: {} };
+    await expect(
+      signAndSubmit.execute({ txCbor: "cbor" }, makeContext()),
+    ).rejects.toMatchObject({ code: "COLD_WALLET" });
+  });
+
+  test("throws SUBMISSION_ERROR when submit fails (includes signedTxCbor in details)", async () => {
+    mockBlaze = {
+      wallet: {},
+      signTransaction: async () => ({
+        toCbor: () => "signed-but-failed",
+        body: () => ({
+          hash: () => ({ toString: () => "hash" }),
+        }),
+        witnessSet: () => ({ vkeys: () => null }),
+      }),
+      submitTransaction: async () => {
+        throw new Error("node rejected");
+      },
+    };
+    try {
+      await signAndSubmit.execute({ txCbor: "valid-cbor" }, makeContext());
+      expect(true).toBe(false); // should not reach
+    } catch (err: any) {
+      expect(err.code).toBe("SUBMISSION_ERROR");
+      expect(err.details.signedTxCbor).toBe("signed-but-failed");
+    }
+  });
+
+  test("has correct metadata", () => {
+    expect(signAndSubmit.name).toBe("sign-and-submit");
+    expect(signAndSubmit.category).toBe("wallet");
+  });
+});
+
+describe("decode-transaction", () => {
+  beforeEach(() => {
+    mockBlazeError = null;
+
+    // Set up a rich mock transaction for decode tests
+    mockTxFromCbor = () => ({
+      body: () => ({
+        hash: () => ({ toString: () => "decoded-tx-hash" }),
+        inputs: () => ({
+          values: () => [
+            {
+              transactionId: () => ({ toString: () => "input-hash-1" }),
+              index: () => 0n,
+            },
+            {
+              transactionId: () => ({ toString: () => "input-hash-2" }),
+              index: () => 1n,
+            },
+          ],
+        }),
+        outputs: () => [
+          {
+            address: () => ({ toBech32: () => "addr_test1output1" }),
+            amount: () => ({
+              coin: () => 5_000_000n,
+              multiasset: () => undefined,
+            }),
+          },
+          {
+            address: () => ({ toBech32: () => "addr_test1output2" }),
+            amount: () => ({
+              coin: () => 2_000_000n,
+              multiasset: () => undefined,
+            }),
+          },
+        ],
+        fee: () => 180_000n,
+        requiredSigners: () => ({
+          values: () => [
+            { toString: () => "signer-hash-1" },
+            { toString: () => "signer-hash-2" },
+          ],
+        }),
+      }),
+      witnessSet: () => ({
+        vkeys: () => ({ size: () => 2 }),
+      }),
+    });
+  });
+
+  test("decodes a transaction and returns all fields", async () => {
+    const result = await decodeTransaction.execute(
+      { txCbor: "valid-cbor-hex" },
+      makeContext(),
+    );
+    expect(result.txHash).toBe("decoded-tx-hash");
+    expect(result.inputs).toHaveLength(2);
+    expect(result.inputs[0]).toEqual({ txHash: "input-hash-1", outputIndex: 0 });
+    expect(result.inputs[1]).toEqual({ txHash: "input-hash-2", outputIndex: 1 });
+    expect(result.outputs).toHaveLength(2);
+    expect(result.outputs[0].address).toBe("addr_test1output1");
+    expect(result.outputs[0].lovelace).toBe("5000000");
+    expect(result.fee).toBe("180000");
+    expect(result.signatureCount).toBe(2);
+    expect(result.requiredSigners).toEqual(["signer-hash-1", "signer-hash-2"]);
+  });
+
+  test("falls back to hex address when bech32 fails", async () => {
+    mockTxFromCbor = () => ({
+      body: () => ({
+        hash: () => ({ toString: () => "tx-hash" }),
+        inputs: () => ({ values: () => [] }),
+        outputs: () => [
+          {
+            address: () => ({
+              toBech32: () => {
+                throw new Error("cannot convert to bech32");
+              },
+              toBytes: () => "deadbeef",
+            }),
+            amount: () => ({
+              coin: () => 1_000_000n,
+              multiasset: () => undefined,
+            }),
+          },
+        ],
+        fee: () => 100_000n,
+        requiredSigners: () => null,
+      }),
+      witnessSet: () => ({ vkeys: () => null }),
+    });
+
+    const result = await decodeTransaction.execute(
+      { txCbor: "cbor-with-script-address" },
+      makeContext(),
+    );
+    expect(result.outputs[0].address).toBe("deadbeef");
+  });
+
+  test("handles transaction with tokens in outputs", async () => {
+    const policyId = "c".repeat(56);
+    const assetName = "mytoken";
+    const assetId = `${policyId}${assetName}`;
+
+    mockTxFromCbor = () => ({
+      body: () => ({
+        hash: () => ({ toString: () => "tx-hash" }),
+        inputs: () => ({ values: () => [] }),
+        outputs: () => [
+          {
+            address: () => ({ toBech32: () => "addr_test1..." }),
+            amount: () => ({
+              coin: () => 2_000_000n,
+              multiasset: () => ({
+                entries: () => [[assetId, 500n]],
+              }),
+            }),
+          },
+        ],
+        fee: () => 200_000n,
+        requiredSigners: () => null,
+      }),
+      witnessSet: () => ({ vkeys: () => null }),
+    });
+
+    const result = await decodeTransaction.execute(
+      { txCbor: "cbor-with-tokens" },
+      makeContext(),
+    );
+    expect(result.outputs[0].tokens).toHaveLength(1);
+    expect(result.outputs[0].tokens[0].policyId).toBe(policyId);
+    expect(result.outputs[0].tokens[0].quantity).toBe("500");
+  });
+
+  test("throws INVALID_CBOR for bad input", async () => {
+    mockTxFromCbor = () => {
+      throw new Error("bad cbor");
+    };
+    await expect(
+      decodeTransaction.execute({ txCbor: "garbage" }, makeContext()),
+    ).rejects.toMatchObject({ code: "INVALID_CBOR" });
+  });
+
+  test("does not require a wallet (category is 'transaction')", () => {
+    expect(decodeTransaction.name).toBe("decode-transaction");
+    expect(decodeTransaction.category).toBe("transaction");
+  });
+});