clawpowers 2.0.0 → 2.2.1

package/native/pyo3/src/lib.rs

@@ -0,0 +1,407 @@
+//! clawpowers-pyo3 — Python bindings for clawpowers-core.
+
+use pyo3::prelude::*;
+use pyo3::exceptions::PyValueError;
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// WALLET
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// EVM agent wallet — key management and message signing.
+#[pyclass]
+pub struct AgentWallet {
+    inner: clawpowers_wallet::AgentWallet,
+}
+
+#[pymethods]
+impl AgentWallet {
+    /// Generate a fresh random wallet.
+    #[staticmethod]
+    fn generate() -> Self {
+        Self {
+            inner: clawpowers_wallet::AgentWallet::generate(),
+        }
+    }
+
+    /// Import a wallet from a hex private key string.
+    #[staticmethod]
+    fn from_private_key(hex: &str) -> PyResult<Self> {
+        let inner = clawpowers_wallet::AgentWallet::from_private_key(hex)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(Self { inner })
+    }
+
+    /// Return the checksummed EVM address.
+    fn address(&self) -> String {
+        format!("{:#x}", self.inner.address())
+    }
+
+    /// Return the wallet UUID.
+    fn wallet_id(&self) -> String {
+        self.inner.wallet_id.to_string()
+    }
+
+    /// Sign a raw byte buffer. Returns the signature as a string.
+    fn sign_message(&self, msg: &[u8]) -> PyResult<String> {
+        let sig = self.inner.sign_message(msg)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(format!("{sig:?}"))
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TOKENS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Fixed-point token amounts with decimal precision.
+#[pyclass]
+pub struct TokenAmount {
+    inner: clawpowers_tokens::TokenAmount,
+}
+
+#[pymethods]
+impl TokenAmount {
+    /// Create a token amount from a human-readable float value.
+    #[staticmethod]
+    fn from_human(amount: f64, decimals: u8) -> Self {
+        Self {
+            inner: clawpowers_tokens::TokenAmount::from_human(amount, decimals),
+        }
+    }
+
+    /// Convert to a human-readable float.
+    fn to_human(&self) -> f64 {
+        self.inner.to_human()
+    }
+
+    /// Return true if the amount is zero.
+    fn is_zero(&self) -> bool {
+        self.inner.is_zero()
+    }
+
+    /// Serialize to JSON.
+    fn to_json(&self) -> PyResult<String> {
+        serde_json::to_string(&self.inner)
+            .map_err(|e| PyValueError::new_err(e.to_string()))
+    }
+
+    fn __repr__(&self) -> String {
+        format!("TokenAmount({})", self.inner.to_human())
+    }
+}
+
+/// Get the default token registry as JSON.
+#[pyfunction]
+fn default_token_registry() -> PyResult<String> {
+    let reg = clawpowers_tokens::TokenRegistry::default();
+    let tokens: Vec<serde_json::Value> = reg.iter().map(|t| {
+        serde_json::json!({
+            "symbol": t.symbol,
+            "decimals": t.decimals,
+            "chain_id": t.chain_id,
+        })
+    }).collect();
+    serde_json::to_string(&tokens)
+        .map_err(|e| PyValueError::new_err(e.to_string()))
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FEE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Fee schedule calculation.
+#[pyclass]
+pub struct FeeSchedule {
+    inner: clawpowers_fee::FeeSchedule,
+}
+
+#[pymethods]
+impl FeeSchedule {
+    /// Create a fee schedule with default rates (77 bps tx, 30 bps swap).
+    #[staticmethod]
+    fn with_defaults() -> Self {
+        Self {
+            inner: clawpowers_fee::FeeSchedule::default(),
+        }
+    }
+
+    /// Create a fee schedule with custom rates and recipient address.
+    #[new]
+    fn new(tx_bps: u64, swap_bps: u64, recipient_hex: &str) -> PyResult<Self> {
+        let recipient: alloy_primitives::Address = recipient_hex.parse()
+            .map_err(|e: alloy_primitives::hex::FromHexError| PyValueError::new_err(e.to_string()))?;
+        Ok(Self {
+            inner: clawpowers_fee::FeeSchedule::new(tx_bps, swap_bps, recipient),
+        })
+    }
+
+    /// Calculate fee. fee_type: "transaction", "swap", or "custom:<bps>".
+    fn calculate(&self, amount: f64, decimals: u8, fee_type: &str) -> PyResult<String> {
+        let amt = clawpowers_tokens::TokenAmount::from_human(amount, decimals);
+        let ft = match fee_type {
+            "transaction" => clawpowers_fee::FeeType::Transaction,
+            "swap" => clawpowers_fee::FeeType::Swap,
+            s if s.starts_with("custom:") => {
+                let bps: u64 = s[7..].parse()
+                    .map_err(|e: std::num::ParseIntError| PyValueError::new_err(e.to_string()))?;
+                clawpowers_fee::FeeType::Custom(bps)
+            }
+            _ => return Err(PyValueError::new_err(format!("unknown fee type: {fee_type}"))),
+        };
+        let calc = self.inner.calculate(amt, ft)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        let result = serde_json::json!({
+            "gross": calc.gross_amount.to_human(),
+            "fee": calc.fee_amount.to_human(),
+            "net": calc.net_amount.to_human(),
+            "fee_recipient": format!("{:#x}", calc.fee_recipient),
+        });
+        Ok(result.to_string())
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// X402
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// HTTP 402 Payment Required protocol client.
+#[pyclass]
+pub struct X402Client {
+    #[allow(dead_code)]
+    inner: clawpowers_x402::X402Client,
+}
+
+#[pymethods]
+impl X402Client {
+    /// Create a new x402 client.
+    #[new]
+    fn new() -> Self {
+        Self {
+            inner: clawpowers_x402::X402Client::new(),
+        }
+    }
+
+    /// Build an X-Payment header value from payment JSON and signature.
+    fn create_payment_header(&self, payment_json: &str, signature: &str) -> PyResult<String> {
+        let payment: clawpowers_x402::X402PaymentRequired =
+            serde_json::from_str(payment_json)
+                .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(clawpowers_x402::X402Client::create_payment_header(&payment, signature))
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CANONICAL STORE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Append-only canonical record store backed by SQLite.
+#[pyclass(unsendable)]
+pub struct CanonicalStore {
+    inner: clawpowers_canonical::CanonicalStore,
+}
+
+#[pymethods]
+impl CanonicalStore {
+    /// Open or create a persistent store at path.
+    #[staticmethod]
+    fn open(path: &str) -> PyResult<Self> {
+        let inner = clawpowers_canonical::CanonicalStore::new(path)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(Self { inner })
+    }
+
+    /// Create an in-memory store (non-persistent).
+    #[staticmethod]
+    fn in_memory() -> PyResult<Self> {
+        let inner = clawpowers_canonical::CanonicalStore::in_memory()
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(Self { inner })
+    }
+
+    /// Insert a record (JSON). Returns assigned UUID.
+    fn insert(&self, record_json: &str) -> PyResult<String> {
+        let record: clawpowers_canonical::CanonicalRecord =
+            serde_json::from_str(record_json)
+                .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        let id = self.inner.insert(&record)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(id.to_string())
+    }
+
+    /// Get a record by UUID. Returns JSON or None.
+    fn get(&self, id: &str) -> PyResult<Option<String>> {
+        let uuid: uuid::Uuid = id.parse()
+            .map_err(|e: uuid::Error| PyValueError::new_err(e.to_string()))?;
+        let record = self.inner.get(&uuid)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        match record {
+            Some(r) => Ok(Some(serde_json::to_string(&r)
+                .map_err(|e| PyValueError::new_err(e.to_string()))?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Verify record integrity by re-hashing.
+    fn verify_integrity(&self, id: &str) -> PyResult<bool> {
+        let uuid: uuid::Uuid = id.parse()
+            .map_err(|e: uuid::Error| PyValueError::new_err(e.to_string()))?;
+        self.inner.verify_integrity(&uuid)
+            .map_err(|e| PyValueError::new_err(e.to_string()))
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TURBO COMPRESSOR
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// TurboQuant vector compressor for embeddings.
+#[pyclass]
+pub struct TurboCompressor {
+    inner: clawpowers_compression::TurboCompressor,
+}
+
+#[pymethods]
+impl TurboCompressor {
+    /// Create a new compressor for the given dimensions and quantization bits.
+    #[new]
+    fn new(dimensions: usize, bits: u8) -> Self {
+        Self {
+            inner: clawpowers_compression::TurboCompressor::new(
+                clawpowers_compression::CompressionConfig {
+                    dimensions,
+                    quantization_bits: bits,
+                    rotation_seed: 0xDEAD_BEEF_CAFE_1234,
+                },
+            ),
+        }
+    }
+
+    /// Compress a list of f32 values. Returns JSON.
+    fn compress(&self, vector: Vec<f32>) -> PyResult<String> {
+        let compressed = self.inner.compress(&vector)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        serde_json::to_string(&compressed)
+            .map_err(|e| PyValueError::new_err(e.to_string()))
+    }
+
+    /// Decompress a JSON compressed vector back to a list of f32.
+    fn decompress(&self, compressed_json: &str) -> PyResult<Vec<f32>> {
+        let compressed: clawpowers_compression::CompressedVector =
+            serde_json::from_str(compressed_json)
+                .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        self.inner.decompress(&compressed)
+            .map_err(|e| PyValueError::new_err(e.to_string()))
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// WRITE FIREWALL
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Write access control firewall.
+#[pyclass]
+pub struct WriteFirewall {
+    inner: clawpowers_security::WriteFirewall,
+}
+
+#[pymethods]
+impl WriteFirewall {
+    /// Create a firewall from a JSON config with "allowed_namespaces" array.
+    #[new]
+    fn new(config_json: &str) -> PyResult<Self> {
+        #[derive(serde::Deserialize)]
+        struct FirewallConfig {
+            allowed_namespaces: Vec<String>,
+        }
+        let config: FirewallConfig = serde_json::from_str(config_json)
+            .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        Ok(Self {
+            inner: clawpowers_security::WriteFirewall::new(config.allowed_namespaces),
+        })
+    }
+
+    /// Evaluate a write request (JSON). Returns JSON decision.
+    fn evaluate(&self, request_json: &str) -> PyResult<String> {
+        let req: clawpowers_security::WriteRequest =
+            serde_json::from_str(request_json)
+                .map_err(|e| PyValueError::new_err(e.to_string()))?;
+        let decision = self.inner.evaluate(&req);
+        serde_json::to_string(&decision)
+            .map_err(|e| PyValueError::new_err(e.to_string()))
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// POLICY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// Evaluate a spending policy on a proposed transaction.
+#[pyfunction]
+fn evaluate_spending_policy(
+    max_per_tx: f64,
+    decimals: u8,
+    fail_closed: bool,
+    tx_amount: f64,
+    tx_recipient: &str,
+) -> PyResult<String> {
+    let policy = clawpowers_policy::SpendingPolicy::builder()
+        .max_per_tx(clawpowers_tokens::TokenAmount::from_human(max_per_tx, decimals))
+        .fail_closed(fail_closed)
+        .build();
+    let recipient: alloy_primitives::Address = tx_recipient.parse()
+        .map_err(|e: alloy_primitives::hex::FromHexError| PyValueError::new_err(e.to_string()))?;
+    let tx = clawpowers_policy::ProposedTx {
+        recipient,
+        amount: clawpowers_tokens::TokenAmount::from_human(tx_amount, decimals),
+        merchant_allowlist_check: false,
+    };
+    let decision = policy.evaluate(&tx);
+    let result = match decision {
+        clawpowers_policy::PolicyDecision::Approve => "approve".to_string(),
+        clawpowers_policy::PolicyDecision::Deny(reason) => format!("deny: {reason}"),
+        clawpowers_policy::PolicyDecision::RequireHumanApproval(reason) => format!("escalate: {reason}"),
+    };
+    Ok(result)
+}
+
+/// Compute SHA-256 hash of content (from canonical crate).
+#[pyfunction]
+fn compute_sha256(content: &str) -> String {
+    clawpowers_canonical::compute_sha256(content)
+}
+
+/// Compute cosine similarity between two f32 vectors.
+#[pyfunction]
+fn cosine_similarity(a: Vec<f32>, b: Vec<f32>) -> f32 {
+    clawpowers_compression::cosine_similarity(&a, &b)
+}
+
+/// Compute L2 distance between two f32 vectors.
+#[pyfunction]
+fn l2_distance(a: Vec<f32>, b: Vec<f32>) -> f32 {
+    clawpowers_compression::l2_distance(&a, &b)
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MODULE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/// ClawPowers Core — Rust-powered Python bindings for the agent economy.
+#[pymodule]
+fn clawpowers_core(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // Classes
+    m.add_class::<AgentWallet>()?;
+    m.add_class::<TokenAmount>()?;
+    m.add_class::<FeeSchedule>()?;
+    m.add_class::<X402Client>()?;
+    m.add_class::<CanonicalStore>()?;
+    m.add_class::<TurboCompressor>()?;
+    m.add_class::<WriteFirewall>()?;
+    // Functions
+    m.add_function(wrap_pyfunction!(default_token_registry, m)?)?;
+    m.add_function(wrap_pyfunction!(evaluate_spending_policy, m)?)?;
+    m.add_function(wrap_pyfunction!(compute_sha256, m)?)?;
+    m.add_function(wrap_pyfunction!(cosine_similarity, m)?)?;
+    m.add_function(wrap_pyfunction!(l2_distance, m)?)?;
+    Ok(())
+}

package/native/pyo3/tests/test_smoke.py

@@ -0,0 +1,180 @@
+"""Smoke test for clawpowers_core PyO3 bindings.
+
+Exercises at least one function from: wallet, tokens, fee, x402, canonical,
+compression, security, and policy (8 crates).
+"""
+
+import json
+import sys
+
+
+def main():
+    import clawpowers_core as cc
+
+    passed = 0
+    total = 0
+
+    # ── 1. Wallet ──────────────────────────────────────────────────────────
+    total += 1
+    w = cc.AgentWallet.generate()
+    addr = w.address()
+    assert addr.startswith("0x"), f"address should start with 0x, got {addr}"
+    assert len(addr) == 42, f"address should be 42 chars, got {len(addr)}"
+    wid = w.wallet_id()
+    assert len(wid) == 36, f"wallet_id should be UUID, got {wid}"
+    sig = w.sign_message(b"hello clawpowers")
+    assert len(sig) > 0, "signature should not be empty"
+    passed += 1
+    print(f"  ✅ wallet: address={addr[:10]}…")
+
+    # ── 2. Wallet from private key ─────────────────────────────────────────
+    total += 1
+    w2 = cc.AgentWallet.from_private_key(
+        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+    )
+    assert w2.address() == "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"
+    passed += 1
+    print(f"  ✅ wallet from_private_key: {w2.address()[:10]}…")
+
+    # ── 3. Tokens ──────────────────────────────────────────────────────────
+    total += 1
+    t = cc.TokenAmount.from_human(123.456, 6)
+    assert abs(t.to_human() - 123.456) < 0.001
+    assert not t.is_zero()
+    j = t.to_json()
+    assert "raw" in j
+    passed += 1
+    print(f"  ✅ tokens: {t}")
+
+    # ── 4. Token registry ──────────────────────────────────────────────────
+    total += 1
+    reg = json.loads(cc.default_token_registry())
+    symbols = {t["symbol"] for t in reg}
+    assert "USDC" in symbols
+    assert "ETH" in symbols
+    passed += 1
+    print(f"  ✅ token registry: {len(reg)} tokens")
+
+    # ── 5. Fee ─────────────────────────────────────────────────────────────
+    total += 1
+    fs = cc.FeeSchedule.with_defaults()
+    calc = json.loads(fs.calculate(1000.0, 6, "transaction"))
+    assert abs(calc["fee"] - 7.7) < 0.001, f"fee should be 7.7, got {calc['fee']}"
+    assert abs(calc["net"] - 992.3) < 0.001
+    passed += 1
+    print(f"  ✅ fee: gross={calc['gross']} fee={calc['fee']} net={calc['net']}")
+
+    # ── 6. X402 ────────────────────────────────────────────────────────────
+    total += 1
+    x = cc.X402Client()
+    payment_json = json.dumps({
+        "payment_url": "https://pay.example.com/pay",
+        "amount": "1.00",
+        "token": "USDC",
+        "chain_id": 8453,
+        "recipient": "0xrecipient",
+        "memo": None,
+    })
+    header = x.create_payment_header(payment_json, "0xsig")
+    assert "0xrecipient" in header
+    assert "0xsig" in header
+    passed += 1
+    print(f"  ✅ x402: header={header[:40]}…")
+
+    # ── 7. Canonical store ─────────────────────────────────────────────────
+    total += 1
+    store = cc.CanonicalStore.in_memory()
+    record = json.dumps({
+        "id": "00000000-0000-0000-0000-000000000001",
+        "namespace": "test",
+        "content": "hello world",
+        "content_hash": cc.compute_sha256("hello world"),
+        "embedding": None,
+        "metadata": {},
+        "created_at": "2026-03-31T00:00:00Z",
+        "provenance": "smoke-test",
+    })
+    rid = store.insert(record)
+    assert len(rid) == 36, f"insert should return UUID, got {rid}"
+    fetched = store.get(rid)
+    assert fetched is not None
+    assert json.loads(fetched)["content"] == "hello world"
+    assert store.verify_integrity(rid) is True
+    passed += 1
+    print(f"  ✅ canonical: inserted and verified id={rid[:8]}…")
+
+    # ── 8. Compression ─────────────────────────────────────────────────────
+    total += 1
+    comp = cc.TurboCompressor(64, 8)
+    vec = [float(i) / 64.0 for i in range(64)]
+    compressed = comp.compress(vec)
+    cdata = json.loads(compressed)
+    assert len(cdata["quantized"]) == 64
+    decompressed = comp.decompress(compressed)
+    assert len(decompressed) == 64
+    # Check roundtrip fidelity
+    err = sum((a - b) ** 2 for a, b in zip(vec, decompressed)) ** 0.5
+    assert err < 1.0, f"roundtrip error too high: {err}"
+    passed += 1
+    print(f"  ✅ compression: {len(vec)} dims → {len(cdata['quantized'])} quantized, err={err:.4f}")
+
+    # ── 9. Security (WriteFirewall) ────────────────────────────────────────
+    total += 1
+    fw = cc.WriteFirewall('{"allowed_namespaces": ["agents", "test"]}')
+    decision = json.loads(fw.evaluate(json.dumps({
+        "namespace": "agents",
+        "content": "normal content",
+        "trust_level": "Agent",
+        "source": "test-agent",
+    })))
+    assert decision == "Allow", f"expected Allow, got {decision}"
+    # Test deny for unlisted namespace
+    deny = json.loads(fw.evaluate(json.dumps({
+        "namespace": "forbidden",
+        "content": "bad",
+        "trust_level": "Agent",
+        "source": "test",
+    })))
+    assert "Deny" in str(deny), f"expected Deny, got {deny}"
+    passed += 1
+    print(f"  ✅ security: allow={decision}, deny works")
+
+    # ── 10. Policy ─────────────────────────────────────────────────────────
+    total += 1
+    result = cc.evaluate_spending_policy(
+        100.0, 6, True, 50.0,
+        "0x0000000000000000000000000000000000000000"
+    )
+    assert result == "approve", f"expected approve, got {result}"
+    # Test deny
+    result2 = cc.evaluate_spending_policy(
+        100.0, 6, True, 200.0,
+        "0x0000000000000000000000000000000000000000"
+    )
+    assert result2.startswith("deny"), f"expected deny, got {result2}"
+    passed += 1
+    print(f"  ✅ policy: approve ok, deny ok")
+
+    # ── 11. Utility functions ──────────────────────────────────────────────
+    total += 1
+    h = cc.compute_sha256("test")
+    assert len(h) == 64, f"sha256 should be 64 hex chars, got {len(h)}"
+    sim = cc.cosine_similarity([1.0, 0.0], [1.0, 0.0])
+    assert abs(sim - 1.0) < 0.001
+    dist = cc.l2_distance([0.0, 0.0], [3.0, 4.0])
+    assert abs(dist - 5.0) < 0.001
+    passed += 1
+    print(f"  ✅ utilities: sha256, cosine_similarity, l2_distance")
+
+    print(f"\n{'='*60}")
+    print(f"  SMOKE TEST: {passed}/{total} passed")
+    print(f"  Crates exercised: wallet, tokens, fee, x402, canonical,")
+    print(f"    compression, security, policy (8 crates)")
+    print(f"{'='*60}")
+
+    if passed < total:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/native/wasm/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "clawpowers-wasm"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "WASM bindings for ClawPowers core — tokens, fees, policy, compression, index, canonical, verification, security"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+wasm-bindgen = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+serde-wasm-bindgen = "0.6"
+
+# Crates that compile cleanly to WASM
+clawpowers-tokens = { path = "../crates/tokens" }
+clawpowers-fee = { path = "../crates/fee" }
+clawpowers-policy = { path = "../crates/policy" }
+clawpowers-compression = { path = "../crates/compression" }
+clawpowers-index = { path = "../crates/index" }
+
+# Crates that need WASM feature flag
+clawpowers-canonical = { path = "../crates/canonical", default-features = false, features = ["wasm"] }
+clawpowers-verification = { path = "../crates/verification", default-features = false, features = ["wasm"] }
+clawpowers-security = { path = "../crates/security", default-features = false, features = ["wasm"] }
+
+# alloy-primitives needed for Address type
+alloy-primitives = { workspace = true }
+k256 = { version = "0.13", features = ["ecdsa", "sha2"] }
+clawpowers-evm-eth = { path = "../crates/evm-eth" }
+uuid = { version = "1", features = ["v4", "serde", "js"] }
+chrono = { workspace = true }
+
+# WASM-compatible random number generation
+getrandom = { version = "0.3", features = ["wasm_js"] }
+
+# k256 → rand_core pulls getrandom 0.2; enable `js` for wasm32-unknown-unknown
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2", features = ["js"] }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3"

package/native/wasm/pkg/.gitignore

@@ -0,0 +1,6 @@
+*
+!.gitignore
+!*.js
+!*.d.ts
+!*.wasm
+!package.json