Crate kaspa_wasm
source ·Expand description
§rusty-kaspa WASM32 bindings
Rusty-Kaspa WASM32 bindings offer direct integration of Rust code and Rusty-Kaspa codebase within JavaScript environments such as Node.js and Web Browsers.
§Documentation
Please note that while WASM directly binds JavaScript and Rust resources, their names on JavaScript side are different from their name in Rust as they conform to the ‘camelCase’ convention in JavaScript and to the ‘snake_case’ convention in Rust.
§Interfaces
The APIs are currently separated into the following groups (this will be expanded in the future):
- Transaction API — Bindings for primitives related to transactions.
- RPC API — RPC interface bindings for the Kaspa node using WebSocket (wRPC) connections.
- Wallet API — API for async core wallet processing tasks.
§NPM Modules
For JavaScript / TypeScript environments, there are two available NPM modules:
The kaspa-wasm
module is a pure WASM32 module that includes
the entire wallet framework, but does not support RPC due to an absence
of a native WebSocket in NodeJs environment, while
the kaspa
module includes isomorphic-ws
dependency simulating
the W3C WebSocket and thus supports RPC.
§Examples
JavaScript examples for using this framework can be found at: https://github.com/kaspanet/rusty-kaspa/tree/master/wasm/nodejs
§WASM32 Binaries
For pre-built browser-compatible WASM32 redistributables of this framework please see the releases section of the Rusty Kaspa repository at https://github.com/kaspanet/rusty-kaspa/releases.
§Using RPC
NODEJS: If you are building from source, to use WASM RPC client in the NodeJS environment, you need to introduce a W3C WebSocket object before loading the WASM32 library. You can use any Node.js module that exposes a W3C-compatible WebSocket implementation. Two of such modules are WebSocket (provides a custom implementation) and isomorphic-ws (built on top of the ws WebSocket module).
You can use the following shims:
// WebSocket
globalThis.WebSocket = require('websocket').w3cwebsocket;
// isomorphic-ws
globalThis.WebSocket = require('isomorphic-ws');
§Loading in a Web App
<html>
<head>
<script type="module">
import * as kaspa_wasm from './kaspa/kaspa-wasm.js';
(async () => {
const kaspa = await kaspa_wasm.default('./kaspa/kaspa-wasm_bg.wasm');
// ...
})();
</script>
</head>
<body></body>
</html>
§Loading in a Node.js App
// W3C WebSocket module shim
// this is provided by NPM `kaspa` module and is only needed
// if you are building WASM libraries for NodeJS from source
// globalThis.WebSocket = require('websocket').w3cwebsocket;
let {RpcClient,Encoding,initConsolePanicHook} = require('./kaspa-rpc');
// enabling console panic hooks allows WASM to print panic details to console
// initConsolePanicHook();
// enabling browser panic hooks will create a full-page DIV with panic details
// this is useful for mobile devices where console is not available
// initBrowserPanicHook();
// if port is not specified, it will use the default port for the specified network
const rpc = new RpcClient("127.0.0.1", Encoding.Borsh, "testnet-10");
(async () => {
try {
await rpc.connect();
let info = await rpc.getInfo();
console.log(info);
} finally {
await rpc.disconnect();
}
})();
For more details, please follow the integrating with Kaspa guide.
Re-exports§
pub use crate::utils::*;
Modules§
keypair
module encapsulatesKeypair
andPrivateKey
. TheKeypair
provides access to the secret and public keys.- Kaspa RPC interface
Structs§
- Kaspa
Address
struct that serializes to and from an address format string:kaspa:qz0s...t8cv
. Generator
is a type capable of generating transactions based on a supplied set of UTXO entries or a UTXO entry producer (such asUtxoContext
). TheGenerator
accumulates UTXO entries until it can generate a transaction that meets the requested amount or until the total mass of created inputs exceeds the allowed transaction mass, at which point it will produce a compound transaction by forwarding all selected UTXO entries to the supplied change address and prepare to start generating a new transaction. Such sequence of daisy-chained transactions is known as a “batch”. Each compound transaction results in a new UTXO, which is immediately reused in the subsequent transaction.- Supports the following properties (all values must be supplied in SOMPI):
- Data structure that contains a secret and public keys.
- Data structure that envelops a Private Key
- ScriptBuilder provides a facility for building custom scripts. It allows you to push opcodes, ints, and data while respecting canonical encoding. In general it does not ensure the script will execute correctly, however any data pushes which would exceed the maximum allowed script engine limits and are therefore guaranteed not to execute will not be pushed and will result in the Script function returning an error.
- Represents a Kaspad ScriptPublicKey
- Represents a generic mutable transaction
- Represents a Kaspa transaction
- Represents a Kaspa transaction input
- Represents a Kaspa transaction outpoint
- Represents a Kaspad transaction output
- A simple collection of UTXO entries. This struct is used to retain a set of UTXO entries in the WASM memory for faster processing. This struct keeps a list of entries represented by
UtxoEntryReference
struct. This data structure is used internally by the framework, but is exposed for convenience. Please consider usingUtxoContect
instead.
Enums§
- Kaspa
Address
version (PubKey
,PubKey ECDSA
,ScriptHash
)
Traits§
Functions§
- Create a basic transaction without any mass limit checks.
- Creates a set of transactions using transaction
Generator
. - Creates a set of transactions using transaction
Generator
. - find Consensus parameters for given Address
- find Consensus parameters for given NetworkType
signTransaction()
is a helper function to sign a transaction using a private key array or a signer array.- Sign a transaction using schnorr, returns a new transaction with the signatures added. The resulting transaction may be partially signed if the supplied keys are not sufficient to sign all of its inputs.