runtime/wasm: Update tests to BigInt and test BigInt/i32/hex conversions

Author: Jannis Pohlmann

runtime/wasm/src/asc_abi/test.rs

@@ -7,6 +7,7 @@ use wasmi::{
     RuntimeValue, Signature,
 };
 
+use graph::prelude::BigInt;
 use graph::web3::types::{H160, U256};
 
 use super::class::*;
@@ -160,18 +161,26 @@ fn string() {
 }
 
 #[test]
-fn abi_u256() {
+fn abi_big_int() {
     let module = TestModule::new("wasm_test/abi_classes.wasm");
-    let address = U256::zero();
 
-    // As an `Uint64Array`
-    let array_buffer: AscPtr<Uint8Array> = module.asc_new(&address);
-    let new_uint_obj: AscPtr<Uint8Array> = module.takes_ptr_returns_ptr("test_uint", array_buffer);
-
-    // This should have 1 added to the first and last `u64`s.
-    let new_uint: U256 = module.asc_get(new_uint_obj);
-
-    assert_eq!(new_uint, U256([1, 0, 0, 1]))
+    // Test passing in 0 and increment it by 1
+    let old_uint = U256::zero();
+    let array_buffer: AscPtr<AscBigInt> = module.asc_new(&BigInt::from_unsigned_u256(&old_uint));
+    let new_uint_obj: AscPtr<AscBigInt> = module.takes_ptr_returns_ptr("test_uint", array_buffer);
+    let new_uint: BigInt = module.asc_get(new_uint_obj);
+    assert_eq!(new_uint, BigInt::from(1 as i32));
+    let new_uint = new_uint.to_unsigned_u256();
+    assert_eq!(new_uint, U256([1, 0, 0, 0]));
+
+    // Test passing in -50 and increment it by 1
+    let old_uint = BigInt::from(-50);
+    let array_buffer: AscPtr<AscBigInt> = module.asc_new(&old_uint);
+    let new_uint_obj: AscPtr<AscBigInt> = module.takes_ptr_returns_ptr("test_uint", array_buffer);
+    let new_uint: BigInt = module.asc_get(new_uint_obj);
+    assert_eq!(new_uint, BigInt::from(-49 as i32));
+    let new_uint_from_u256 = BigInt::from_signed_u256(&new_uint.to_signed_u256());
+    assert_eq!(new_uint, new_uint_from_u256);
 }
 
 #[test]
@@ -420,8 +429,6 @@ fn abi_store_value() {
         module.asc_get(module.takes_ptr_returns_ptr("value_from_bigint", bytes_ptr));
     assert_eq!(
         new_value,
-        Value::BigInt(::graph::data::store::scalar::BigInt::from_signed_bytes_le(
-            bytes
-        ))
+        Value::BigInt(::graph::data::store::scalar::BigInt::from_unsigned_bytes_le(bytes))
     );
 }

runtime/wasm/src/module/test.rs

@@ -14,7 +14,7 @@ use graph::components::subgraph::*;
 use graph::data::store::scalar;
 use graph::data::subgraph::*;
 use graph::util;
-use graph::web3::types::Address;
+use graph::web3::types::{Address, H256, U256};
 use hex;
 use std::collections::HashMap;
 use std::io::Cursor;
@@ -365,3 +365,94 @@ fn token_numeric_conversion() {
         .expect("call did not return i32");
     assert_eq!(num, num_return);
 }
+
+#[test]
+fn big_int_to_from_i32() {
+    let mut module = test_module(mock_data_source("wasm_test/big_int_to_from_i32.wasm"));
+
+    // Convert i32 to BigInt
+    let input: i32 = -157;
+    let output_ptr: AscPtr<AscBigInt> = module
+        .module
+        .invoke_export(
+            "i32_to_big_int",
+            &[RuntimeValue::from(input)],
+            &mut module.externals,
+        ).expect("call failed")
+        .expect("call returned nothing")
+        .try_into()
+        .expect("call did not return pointer");
+    let output: BigInt = module.heap.asc_get(output_ptr);
+    assert_eq!(output, BigInt::from(-157 as i32));
+
+    // Convert BigInt to i32
+    let input = BigInt::from(-50 as i32);
+    let input_ptr: AscPtr<AscBigInt> = module.heap.asc_new(&input);
+    let output: i32 = module
+        .module
+        .invoke_export(
+            "big_int_to_i32",
+            &[RuntimeValue::from(input_ptr)],
+            &mut module.externals,
+        ).expect("call failed")
+        .expect("call returned nothing")
+        .try_into()
+        .expect("call did not return pointer");
+    assert_eq!(output, -50 as i32);
+}
+
+#[test]
+fn big_int_to_hex() {
+    let mut module = test_module(mock_data_source("wasm_test/big_int_to_hex.wasm"));
+
+    // Convert zero to hex
+    let zero = BigInt::from_unsigned_u256(&U256::zero());
+    let zero: AscPtr<AscBigInt> = module.heap.asc_new(&zero);
+    let zero_hex_ptr: AscPtr<AscString> = module
+        .module
+        .invoke_export(
+            "big_int_to_hex",
+            &[RuntimeValue::from(zero)],
+            &mut module.externals,
+        ).expect("call failed")
+        .expect("call returned nothing")
+        .try_into()
+        .expect("call did not return pointer");
+    let zero_hex_str: String = module.heap.asc_get(zero_hex_ptr);
+    assert_eq!(zero_hex_str, "0x00");
+
+    // Convert 1 to hex
+    let one = BigInt::from_unsigned_u256(&U256::one());
+    let one: AscPtr<AscBigInt> = module.heap.asc_new(&one);
+    let one_hex_ptr: AscPtr<AscString> = module
+        .module
+        .invoke_export(
+            "big_int_to_hex",
+            &[RuntimeValue::from(one)],
+            &mut module.externals,
+        ).expect("call failed")
+        .expect("call returned nothing")
+        .try_into()
+        .expect("call did not return pointer");
+    let one_hex_str: String = module.heap.asc_get(one_hex_ptr);
+    assert_eq!(one_hex_str, "0x01");
+
+    // Convert U256::max_value() to hex
+    let u256_max = BigInt::from_unsigned_u256(&U256::max_value());
+    let u256_max: AscPtr<AscBigInt> = module.heap.asc_new(&u256_max);
+    let u256_max_hex_ptr: AscPtr<AscString> = module
+        .module
+        .invoke_export(
+            "big_int_to_hex",
+            &[RuntimeValue::from(u256_max)],
+            &mut module.externals,
+        ).expect("call failed")
+        .expect("call returned nothing")
+        .try_into()
+        .expect("call did not return pointer");
+    let u256_max_hex_str: String = module.heap.asc_get(u256_max_hex_ptr);
+    assert_eq!(
+        u256_max_hex_str,
+        "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+    );
+}

runtime/wasm/wasm_test/abi_classes.ts

@@ -12,24 +12,23 @@ const array_buffer_header_size = 8;
 export function test_address(address: Address): Address {
   let new_address = address.subarray();
 
-  // Add 1 to the first and last bytes.
+  // Add 1 to the first and last byte.
   new_address[0] += 1;
   new_address[address.length - 1] += 1;
 
   return new_address
 }
 
-// Sequence of 4 `u64`s.
-type Uint = Uint64Array;
+// Sequence of 32 `u8`s.
+type Uint = Uint8Array;
 
-// Clone the Uint to a new buffer, add 1 to the first and last `u64`s and return
+// Clone the Uint to a new buffer, add 1 to the first and last `u8`s and return
 // the new Uint.
 export function test_uint(address: Uint): Uint {
   let new_address = address.subarray();
 
-  // Add 1 to the first and last bytes.
+  // Add 1 to the first byte.
   new_address[0] += 1;
-  new_address[address.length - 1] += 1;
 
   return new_address
 }

runtime/wasm/wasm_test/abi_classes.wasm

@@ -0,0 +1,16 @@
+import "allocator/arena";
+
+export { allocate_memory };
+
+declare namespace typeConversion {
+    function i32ToBigInt(i: i32): Uint8Array
+    function bigIntToI32(n: Uint8Array): i32
+}
+
+export function big_int_to_i32(n: Uint8Array): i32 {
+    return typeConversion.bigIntToI32(n)
+}
+
+export function i32_to_big_int(i: i32): Uint8Array {
+    return typeConversion.i32ToBigInt(i)
+}

runtime/wasm/wasm_test/big_int_to_from_i32.ts

@@ -0,0 +1,11 @@
+import "allocator/arena";
+
+export { allocate_memory };
+
+declare namespace typeConversion {
+    function bigIntToHex(n: Uint8Array): String
+}
+
+export function big_int_to_hex(n: Uint8Array): String {
+    return typeConversion.bigIntToHex(n)
+}