ergo-lib-wasm 0.28.0

WASM bindings for ergo-lib
Documentation 
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

import { expect, assert } from "chai";

import * as ergo from "..";
let ergo_wasm;
beforeEach(async () => {
  ergo_wasm = await ergo;
});

it("decode Constant i32", async () => {
  let enc_v = "048ce5d4e505";
  let c = ergo_wasm.Constant.decode_from_base16(enc_v);
  let c_value = c.to_i32();
  expect(c_value).equal(777689414);
});

it("roundtrip Constant i32", async () => {
  let value = 999999999;
  let c = ergo_wasm.Constant.from_i32(value);
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_i32();
  expect(decoded_c_value).equal(value);
});

it("roundtrip i64 via to_i64", async () => {
  let value_str = "9223372036854775807"; // i64 max value
  let c = ergo_wasm.Constant.from_i64(ergo_wasm.I64.from_str(value_str));
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_i64();
  let decoded_c_value_str = decoded_c_value.to_str();
  expect(decoded_c_value_str).equal(value_str);
});

it("roundtrip Constant byte array", async () => {
  let value = new Uint8Array([1, 1, 2, 255]);
  let c = ergo_wasm.Constant.from_byte_array(value);
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_byte_array();
  expect(decoded_c_value.toString()).equal(value.toString());
});

it("roundtrip Constant array of i32", async () => {
  let value = [2147483647, 1, 2]; // i32 max value
  let c = ergo_wasm.Constant.from_i32_array(value);
  let value_decoded = c.to_i32_array();
  expect(value_decoded.toString()).equal(value.toString());
});

it("roundtrip Constant array of i64", async () => {
  let value_str = ["9223372036854775807", "1", "2"]; // i64 max value
  let c = ergo_wasm.Constant.from_i64_str_array(value_str);
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_i64_str_array();
  expect(decoded_c_value.toString()).equal(value_str.toString());
});

it("Constant from EcPoint bytes", async () => {
  let base16_bytes_str = `02d6b2141c21e4f337e9b065a031a6269fb5a49253094fc6243d38662eb765db00`;
  let c = ergo_wasm.Constant.from_ecpoint_bytes(
    Uint8Array.from(Buffer.from(base16_bytes_str, "hex"))
  );
  expect(c != null);
});

it("roundtrip array of byte arrays", async () => {
  let bytes1 = new Uint8Array([1, 1, 2, 255]);
  let bytes2 = new Uint8Array([5, 6, 7, 255]);
  let concat = [bytes1, bytes2];
  let c = ergo_wasm.Constant.from_coll_coll_byte(concat);
  let decoded_c_value = c.to_coll_coll_byte();
  expect(decoded_c_value.toString()).equal(concat.toString());
});

it("roundtrip tuple of byte arrays", async () => {
  let bytes1 = new Uint8Array([1, 1, 2, 255]);
  let bytes2 = new Uint8Array([5, 6, 7, 255]);
  let c = ergo_wasm.Constant.from_tuple_coll_bytes(bytes1, bytes2);
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_tuple_coll_bytes();
  expect(decoded_c_value.toString()).equal([bytes1, bytes2].toString());
});

it("roundtrip tuple of i64", async () => {
  let value_str1 = "9223372036854775807"; // i64 max value
  let value_str2 = "29428734987293874";
  let c = ergo_wasm.Constant.from_tuple_i64(
    ergo_wasm.I64.from_str(value_str1),
    ergo_wasm.I64.from_str(value_str2)
  );
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_tuple_i64();
  expect(decoded_c_value.toString()).equal([value_str1, value_str2].toString());
});

it("roundtrip ErgoBox", async () => {
  const boxes = ergo_wasm.ErgoBoxes.from_boxes_json([
    {
      boxId: "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
      value: 67500000000,
      ergoTree:
        "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
      assets: [],
      creationHeight: 284761,
      additionalRegisters: {},
      transactionId:
        "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
      index: 1,
    },
  ]);
  let box = boxes.get(0);
  let c = ergo_wasm.Constant.from_ergo_box(box);
  let encoded = c.encode_to_base16();
  let decoded_c = ergo_wasm.Constant.decode_from_base16(encoded);
  let decoded_c_value = decoded_c.to_ergo_box();
  assert(decoded_c_value != null);
  expect(decoded_c_value.to_json().toString()).equal(box.to_json().toString());
});

it("roundtrip Coll[Coll[Byte]]", async () => {
  let bytes1 = new Uint8Array([1, 2, 3]);
  let bytes2 = new Uint8Array([3, 2, 1]);
  let value = [bytes1, bytes2];
  let c_js = ergo_wasm.Constant.from_js(value);
  expect(c_js != null);
  expect(c_js.dbg_tpe()).equal("SColl(SColl(SByte))");
  assert.deepEqual(c_js.to_js(), value);
});

it("roundtrip Coll[(Coll[Byte], Coll[Byte])]", async () => {
  let bytes1 = new Uint8Array([1, 2, 3]);
  let bytes2 = new Uint8Array([3, 2, 1]);
  let value = [ergo_wasm.array_as_tuple([bytes1, bytes2]), ergo_wasm.array_as_tuple([bytes2, bytes1])];
  let expected_value = [[bytes1, bytes2], [bytes2, bytes1]];
  let c_js = ergo_wasm.Constant.from_js(value);
  expect(c_js != null);
  expect(c_js.dbg_tpe()).equal("SColl(STuple([SColl(SByte), SColl(SByte)]))");
  // console.log(c_js.dbg_inner());
  assert.deepEqual(c_js.to_js(), expected_value);
});

it("roundtrip EIP-24 R7 monster type", async () => {
  let bytes1 = new Uint8Array([1, 2, 3]);
  let bytes2 = new Uint8Array([4, 5, 6]);
  let value = ergo_wasm.array_as_tuple([
    [ergo_wasm.array_as_tuple([bytes1, bytes2])],
    ergo_wasm.array_as_tuple([
      [ergo_wasm.array_as_tuple([bytes1, ergo_wasm.array_as_tuple([10, 11])])],
      [ergo_wasm.array_as_tuple([bytes2, ergo_wasm.array_as_tuple([12, 13])])]
    ])
  ]);
  let expected_value = [
    [[bytes1, bytes2]],
    [
      [[bytes1, [10, 11]]],
      [[bytes2, [12, 13]]]
    ]
  ];
  let c_js = ergo_wasm.Constant.from_js(value);
  expect(c_js != null);
  expect(c_js.dbg_tpe()).equal("STuple([SColl(STuple([SColl(SByte), SColl(SByte)])), STuple([SColl(STuple([SColl(SByte), STuple([SInt, SInt])])), SColl(STuple([SColl(SByte), STuple([SInt, SInt])]))])])");
  // console.log(c_js.dbg_inner());
  assert.deepEqual(c_js.to_js(), expected_value);
});

it("roundtrip i64", async () => {
  let value_str = "9223372036854775807"; // i64 max value
  let c_js = ergo_wasm.Constant.from_js(value_str);
  let decoded_c_value = c_js.to_js();
  expect(c_js.dbg_tpe()).equal("SLong");
  expect(decoded_c_value).equal(value_str);
});

it("roundtrip BigInt", async () => {
  let bigint = BigInt(92233720368547758071111111111111111111111111n);
  let c_js = ergo_wasm.Constant.from_js(bigint);
  expect(c_js.dbg_tpe()).equal("SBigInt");
  let decoded_c_value = c_js.to_js();
  expect(decoded_c_value).equal(bigint);
  assert.deepEqual(c_js.to_js(), bigint);
});

it("too big BigInt fail", async () => {
  let bigint = BigInt(92233720368547758071111111111111111111111111111111111111111111111111111111111111111111111111n);
  expect(function () { ergo_wasm.Constant.from_js(bigint); }).to.throw();
});

it("roundtrip Coll[Coll[Long]]", async () => {
  let array1 = ["9223372036854775807", "1", "2"]; // i64 max value
  let array2 = ["5", "3", "4"];
  let js_value = [array1, array2];
  let c_js = ergo_wasm.Constant.from_js(js_value);
  expect(c_js != null);
  expect(c_js.dbg_tpe()).equal("SColl(SColl(SLong))");
  assert.deepEqual(c_js.to_js(), js_value);
});