@sundaeswap/sprinkles 0.6.0 → 0.7.0

package/dist/esm/Sprinkle/__tests__/wallet-transaction-actions.test.js

@@ -0,0 +1,747 @@
+import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { ActionError } from "../actions/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+// Mock wallet/UTxO data factories
+function makeAddress(bech32 = "addr_test1qz...mock") {
+  return {
+    toBech32: () => bech32
+  };
+}
+function makeAssetId(policyId, assetName) {
+  return `${policyId}${assetName}`;
+}
+function makeUtxo(opts) {
+  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 = {};
+let mockIsHot = true;
+let mockBlazeError = 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 => assetId.slice(0, 56),
+      getAssetName: assetId => assetId.slice(56)
+    },
+    Transaction: {
+      fromCbor: cbor => mockTxFromCbor(cbor)
+    },
+    TxCBOR: s => 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 = () => ({
+  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 = {}) {
+  return {
+    sprinkle: {},
+    settings: {
+      network: "preview",
+      provider: {
+        type: "blockfrost",
+        apiKey: "test"
+      },
+      wallet: {
+        type: "hot",
+        mnemonic: "test words"
+      },
+      ...settingsOverrides
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// 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) {
+      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");
+  });
+});
+//# sourceMappingURL=wallet-transaction-actions.test.js.map