miden-client-web 0.15.5

Web Client library that facilitates interaction with the Miden network
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { _setWasm, buildNetworkNote } from "../standalone.js";

function makeWasm() {
  const target = {
    targetId: vi.fn(() => "targetIdObj"),
    toAttachment: vi.fn(() => "targetAttachment"),
  };
  return {
    AccountId: {
      fromHex: vi.fn((h) => ({ hex: h })),
      fromBech32: vi.fn((b) => ({ bech32: b })),
    },
    NoteType: { Public: "Public", Private: "Private" },
    NetworkAccountTarget: vi.fn().mockImplementation(() => target),
    NoteTag: { withAccountTarget: vi.fn(() => "networkTag") },
    NoteMetadata: vi.fn().mockImplementation(() => "metadata"),
    NoteStorage: vi.fn().mockImplementation(() => "storage"),
    FeltArray: vi.fn().mockImplementation((items) => ({ feltArray: items })),
    Felt: vi.fn().mockImplementation((value) => ({ felt: value })),
    NoteRecipient: { fromScript: vi.fn(() => "recipientFromScript") },
    NoteAttachment: vi.fn().mockImplementation((v) => ({ attachment: v })),
    NoteAssets: vi.fn().mockImplementation(() => "noteAssets"),
    FungibleAsset: vi.fn().mockImplementation(() => "fungibleAsset"),
    Note: { withAttachments: vi.fn(() => "networkNote") },
    __target: target,
  };
}

describe("buildNetworkNote", () => {
  let wasm;
  beforeEach(() => {
    wasm = makeWasm();
    _setWasm(wasm);
  });
  afterEach(() => {
    _setWasm(null);
  });

  it("throws when WASM is not initialized", () => {
    _setWasm(null);
    expect(() =>
      buildNetworkNote({ account: "0xs", target: "0xt", script: "s" })
    ).toThrow("WASM not initialized");
  });

  it("throws when neither recipient nor script is provided", () => {
    expect(() => buildNetworkNote({ account: "0xs", target: "0xt" })).toThrow(
      /recipient.*script/i
    );
  });

  it("throws when both recipient and script are provided", () => {
    expect(() =>
      buildNetworkNote({
        account: "0xs",
        target: "0xt",
        recipient: "customRecipient",
        script: "myScript",
      })
    ).toThrow(/recipient.*script.*not both/i);
  });

  it("builds a network note from a script (fresh recipient, Public, target tag)", () => {
    const executionHint = "onBlockSlot";
    const note = buildNetworkNote({
      account: "0xs",
      target: "0xt",
      executionHint,
      script: "myScript",
      inputs: [1n],
    });
    expect(wasm.NetworkAccountTarget).toHaveBeenCalledWith(
      expect.anything(), // resolved account ref for "0xt"
      executionHint
    );
    expect(wasm.NoteTag.withAccountTarget).toHaveBeenCalledWith("targetIdObj");
    expect(wasm.NoteMetadata).toHaveBeenCalledWith(
      expect.anything(),
      "Public",
      "networkTag"
    );
    expect(wasm.Felt).toHaveBeenCalledWith(1n);
    expect(wasm.FeltArray).toHaveBeenCalledWith([{ felt: 1n }]);
    expect(wasm.NoteRecipient.fromScript).toHaveBeenCalledWith(
      "myScript",
      expect.anything() // NoteStorage instance
    );
    expect(wasm.Note.withAttachments).toHaveBeenCalledWith(
      expect.anything(), // NoteAssets instance
      expect.anything(), // NoteMetadata instance
      "recipientFromScript",
      ["targetAttachment"]
    );
    expect(note).toBe("networkNote");
  });

  it("uses a pre-built recipient and appends an extra attachment", () => {
    buildNetworkNote({
      account: "0xs",
      target: "0xt",
      recipient: "customRecipient",
      attachment: [9n],
    });
    expect(wasm.Note.withAttachments).toHaveBeenCalledWith(
      expect.anything(), // NoteAssets instance
      expect.anything(), // NoteMetadata instance
      "customRecipient",
      ["targetAttachment", { attachment: [9n] }]
    );
  });

  it("defaults to empty assets when none provided", () => {
    buildNetworkNote({ account: "0xs", target: "0xt", script: "s" });
    expect(wasm.NoteAssets).toHaveBeenCalledWith(); // no args -> empty
  });

  it("threads provided assets into the note instead of an empty NoteAssets", () => {
    buildNetworkNote({
      account: "0xs",
      target: "0xt",
      script: "s",
      assets: { token: "0xtoken", amount: 5 },
    });
    expect(wasm.FungibleAsset).toHaveBeenCalledWith(
      expect.anything(), // resolved faucet AccountId
      BigInt(5)
    );
    expect(wasm.NoteAssets).toHaveBeenCalledWith([expect.anything()]); // one FungibleAsset, not empty
  });

  it("uses a pre-built NetworkAccountTarget directly without reconstructing it", () => {
    const preBuilt = Object.create(wasm.NetworkAccountTarget.prototype);
    preBuilt.targetId = vi.fn(() => "preBuiltTargetId");
    preBuilt.toAttachment = vi.fn(() => "preBuiltAttachment");

    buildNetworkNote({
      account: "0xs",
      target: preBuilt,
      script: "s",
    });

    expect(wasm.NetworkAccountTarget).not.toHaveBeenCalled();
    expect(wasm.NoteTag.withAccountTarget).toHaveBeenCalledWith(
      "preBuiltTargetId"
    );
    expect(wasm.Note.withAttachments).toHaveBeenCalledWith(
      expect.anything(), // NoteAssets instance
      expect.anything(), // NoteMetadata instance
      expect.anything(), // recipient
      ["preBuiltAttachment"]
    );
  });
});