JavaScript BigInt to WebAssembly i64 integration
Home Page: https://webassembly.github.io/JS-BigInt-integration/js-api/index.html
License: Other
This proposal has been merged into the main specification.
With the changes in this repository, BigInts have support for bidirectionally converting to 64-bit integer WebAssembly values, which appears as
BigInts can be read or written from WebAssembly memory using the BigInt proposal's BigInt64Array or BigUint64Array; no additional support is needed.
We should also test the WebAssembly.Global with BigInt, I'll probably add them.
At the moment, ToWebAssemblyValue(value) calls ToBigInt64(value) if the expected type is I64. ToBigInt64 throws a TypeError if value is a Number.
This behavior looks unexpected and inconsistent to me, because for all other types, ToWebAssemblyValue works differently.
I'm not convinced that we have to couple wasm.I64 so tightly to js.BigInt. BigInt is needed to allow wasm.I64 to be passed precisely to JavaScript, and also to big numbers precisely from JavaScript to WebAssembly. However, this does not mean that it should not be possible to pass normal numbers to WebAssembly as I64 parameters.
One scenario that comes to my mind is the following: if I want to pass an object to WebAssembly as an I32 parameter, I just have to add the valueOf function to the object to return a number. For an I64 parameter, however, I would have to add a toString function and avoid the valueOf function to avoid a TypeError. [edit] The valueOf function could also return a BigInt, but then it cannot be used for I32 parameters anymore.
Port from v8:
(function TestI64GlobalValueOf() {
var argument = { "value": "i64" };
var global = new WebAssembly.Global(argument, {
valueOf() {
return 123n;
}
});
assertEquals(global.value, 123n);
})();As Dan's review pointed out #4 (review).
Running on Version 81.0.4004.0 (Developer Build) (64-bit) chromium. Also tried on latest stable chrome, and chromium. On Ubuntu 18.0.4.
With chrome://flags/#enable-experimental-webassembly-features for BigInt support for i64 types
I am opening the following page:
https://github.com/theblockstalk/eosio-sovereign-contract-poc/blob/1818f7f9233b7884aefbf1d909b083b28b9e1e59/sovereign/index.html
<!DOCTYPE html>
<html lang='en'>
<head>
<meta charset='utf-8'>
<meta name='viewport' content='width=device-width, initial-scale=1'>
</head>
<body>
<script>
// Source C++ file for .wasm build:
// https://github.com/theblockstalk/eosio-sovereign-contract-poc/tree/b726b0bc7f1881704f8c39ed40e623e39ff661da/contract
//
// This is compiled to wasm using the eosio.cdt tool. The eosio team has reported that the resulting wasm file is compatible with the wasm standard
// https://github.com/EOSIO/eosio.cdt
// This needs to be served over http. Source
// https://github.com/theblockstalk/eosio-sovereign-contract-poc/blob/b726b0bc7f1881704f8c39ed40e623e39ff661da/build/sovereign.wasm
const CONTRACT_WASM_FILE = fetch('../build/sovereign.wasm');
let importObject = {
env: {
memoryBase: 0,
memory: new WebAssembly.Memory({
initial: 256
}),
action_data_size: function() {
console.log('action_data_size');
const i32a = 11;
return i32a;
},
eosio_assert: function(i32a, i32b) {
console.log('eosio_assert');
console.log(i32a);
console.log(i32b);
},
memset: function(i32a, i32b, i32c) {
console.log('memset');
console.log(i32a);
console.log(i32b);
console.log(i32c);
const i32d = 12;
return i32d;
},
read_action_data: function(i32a, i32b) {
console.log('read_action_data');
console.log(i32a);
console.log(i32b);
const i32c = 13;
return i32c;
},
eosio_assert_code: function(condition /*i32*/, error_code /*i64*/) {
console.log('eosio_assert_code');
console.log(condition);
console.log(error_code);
}
}
};
const typedArray = new Uint8Array(CONTRACT_WASM_FILE);
WebAssembly.instantiate(typedArray, importObject).then(module => {
module.instance.exports.apply(
Uint8Array("sovereign"),
Uint8Array("dablockstalk"),
Uint8Array("hi")
);
});
</script>
</body>
</html>
And getting the following error
index.js:61 Uncaught (in promise) SyntaxError: Cannot convert 0,0,152,204,169,171,54,197 to a BigInt
I'm not sure where the BigInt is being parsed as I cannot see any references to my code, or chromium code.
Entry requirements:
In the current version of this proposal, any JavaScript object can be imported as an i64 global as long as ToBigInt64 does not throw an exception on that object. However, in the main WebAssembly spec we require at the moment that only JavaScript numbers are valid values for imported globals. I think this behavior was introduced to the WebAssembly spec with the mutable-globals proposal.
With this issue I wanted to flag this inconsistenc, so that we don't forget about it.
Embedders implement the feature.
Example:
var module = builder.instantiate({
mod: {
fn(arg) {
assert_typeof(arg, BigInt);
},
}
});For example:
new WebAssembly.Global({ "value": "i64" }, 666);Which should throw.
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.