d803bfe2b1
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
8050 lines
254 KiB
JavaScript
8050 lines
254 KiB
JavaScript
let wasm;
|
|
|
|
function addToExternrefTable0(obj) {
|
|
const idx = wasm.__externref_table_alloc();
|
|
wasm.__wbindgen_externrefs.set(idx, obj);
|
|
return idx;
|
|
}
|
|
|
|
function _assertClass(instance, klass) {
|
|
if (!(instance instanceof klass)) {
|
|
throw new Error(`expected instance of ${klass.name}`);
|
|
}
|
|
}
|
|
|
|
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(state => state.dtor(state.a, state.b));
|
|
|
|
function debugString(val) {
|
|
// primitive types
|
|
const type = typeof val;
|
|
if (type == 'number' || type == 'boolean' || val == null) {
|
|
return `${val}`;
|
|
}
|
|
if (type == 'string') {
|
|
return `"${val}"`;
|
|
}
|
|
if (type == 'symbol') {
|
|
const description = val.description;
|
|
if (description == null) {
|
|
return 'Symbol';
|
|
} else {
|
|
return `Symbol(${description})`;
|
|
}
|
|
}
|
|
if (type == 'function') {
|
|
const name = val.name;
|
|
if (typeof name == 'string' && name.length > 0) {
|
|
return `Function(${name})`;
|
|
} else {
|
|
return 'Function';
|
|
}
|
|
}
|
|
// objects
|
|
if (Array.isArray(val)) {
|
|
const length = val.length;
|
|
let debug = '[';
|
|
if (length > 0) {
|
|
debug += debugString(val[0]);
|
|
}
|
|
for(let i = 1; i < length; i++) {
|
|
debug += ', ' + debugString(val[i]);
|
|
}
|
|
debug += ']';
|
|
return debug;
|
|
}
|
|
// Test for built-in
|
|
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
let className;
|
|
if (builtInMatches && builtInMatches.length > 1) {
|
|
className = builtInMatches[1];
|
|
} else {
|
|
// Failed to match the standard '[object ClassName]'
|
|
return toString.call(val);
|
|
}
|
|
if (className == 'Object') {
|
|
// we're a user defined class or Object
|
|
// JSON.stringify avoids problems with cycles, and is generally much
|
|
// easier than looping through ownProperties of `val`.
|
|
try {
|
|
return 'Object(' + JSON.stringify(val) + ')';
|
|
} catch (_) {
|
|
return 'Object';
|
|
}
|
|
}
|
|
// errors
|
|
if (val instanceof Error) {
|
|
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
}
|
|
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
return className;
|
|
}
|
|
|
|
function getArrayF32FromWasm0(ptr, len) {
|
|
ptr = ptr >>> 0;
|
|
return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
}
|
|
|
|
function getArrayJsValueFromWasm0(ptr, len) {
|
|
ptr = ptr >>> 0;
|
|
const mem = getDataViewMemory0();
|
|
const result = [];
|
|
for (let i = ptr; i < ptr + 4 * len; i += 4) {
|
|
result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
|
|
}
|
|
wasm.__externref_drop_slice(ptr, len);
|
|
return result;
|
|
}
|
|
|
|
function getArrayU8FromWasm0(ptr, len) {
|
|
ptr = ptr >>> 0;
|
|
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
}
|
|
|
|
let cachedDataViewMemory0 = null;
|
|
function getDataViewMemory0() {
|
|
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
}
|
|
return cachedDataViewMemory0;
|
|
}
|
|
|
|
let cachedFloat32ArrayMemory0 = null;
|
|
function getFloat32ArrayMemory0() {
|
|
if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
|
|
cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
|
|
}
|
|
return cachedFloat32ArrayMemory0;
|
|
}
|
|
|
|
function getStringFromWasm0(ptr, len) {
|
|
ptr = ptr >>> 0;
|
|
return decodeText(ptr, len);
|
|
}
|
|
|
|
let cachedUint8ArrayMemory0 = null;
|
|
function getUint8ArrayMemory0() {
|
|
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
}
|
|
return cachedUint8ArrayMemory0;
|
|
}
|
|
|
|
function handleError(f, args) {
|
|
try {
|
|
return f.apply(this, args);
|
|
} catch (e) {
|
|
const idx = addToExternrefTable0(e);
|
|
wasm.__wbindgen_exn_store(idx);
|
|
}
|
|
}
|
|
|
|
function isLikeNone(x) {
|
|
return x === undefined || x === null;
|
|
}
|
|
|
|
function makeMutClosure(arg0, arg1, dtor, f) {
|
|
const state = { a: arg0, b: arg1, cnt: 1, dtor };
|
|
const real = (...args) => {
|
|
|
|
// First up with a closure we increment the internal reference
|
|
// count. This ensures that the Rust closure environment won't
|
|
// be deallocated while we're invoking it.
|
|
state.cnt++;
|
|
const a = state.a;
|
|
state.a = 0;
|
|
try {
|
|
return f(a, state.b, ...args);
|
|
} finally {
|
|
state.a = a;
|
|
real._wbg_cb_unref();
|
|
}
|
|
};
|
|
real._wbg_cb_unref = () => {
|
|
if (--state.cnt === 0) {
|
|
state.dtor(state.a, state.b);
|
|
state.a = 0;
|
|
CLOSURE_DTORS.unregister(state);
|
|
}
|
|
};
|
|
CLOSURE_DTORS.register(real, state, state);
|
|
return real;
|
|
}
|
|
|
|
function passArray8ToWasm0(arg, malloc) {
|
|
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
WASM_VECTOR_LEN = arg.length;
|
|
return ptr;
|
|
}
|
|
|
|
function passArrayF32ToWasm0(arg, malloc) {
|
|
const ptr = malloc(arg.length * 4, 4) >>> 0;
|
|
getFloat32ArrayMemory0().set(arg, ptr / 4);
|
|
WASM_VECTOR_LEN = arg.length;
|
|
return ptr;
|
|
}
|
|
|
|
function passArrayJsValueToWasm0(array, malloc) {
|
|
const ptr = malloc(array.length * 4, 4) >>> 0;
|
|
for (let i = 0; i < array.length; i++) {
|
|
const add = addToExternrefTable0(array[i]);
|
|
getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
|
|
}
|
|
WASM_VECTOR_LEN = array.length;
|
|
return ptr;
|
|
}
|
|
|
|
function passStringToWasm0(arg, malloc, realloc) {
|
|
if (realloc === undefined) {
|
|
const buf = cachedTextEncoder.encode(arg);
|
|
const ptr = malloc(buf.length, 1) >>> 0;
|
|
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
WASM_VECTOR_LEN = buf.length;
|
|
return ptr;
|
|
}
|
|
|
|
let len = arg.length;
|
|
let ptr = malloc(len, 1) >>> 0;
|
|
|
|
const mem = getUint8ArrayMemory0();
|
|
|
|
let offset = 0;
|
|
|
|
for (; offset < len; offset++) {
|
|
const code = arg.charCodeAt(offset);
|
|
if (code > 0x7F) break;
|
|
mem[ptr + offset] = code;
|
|
}
|
|
if (offset !== len) {
|
|
if (offset !== 0) {
|
|
arg = arg.slice(offset);
|
|
}
|
|
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
const ret = cachedTextEncoder.encodeInto(arg, view);
|
|
|
|
offset += ret.written;
|
|
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
}
|
|
|
|
WASM_VECTOR_LEN = offset;
|
|
return ptr;
|
|
}
|
|
|
|
function takeFromExternrefTable0(idx) {
|
|
const value = wasm.__wbindgen_externrefs.get(idx);
|
|
wasm.__externref_table_dealloc(idx);
|
|
return value;
|
|
}
|
|
|
|
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
cachedTextDecoder.decode();
|
|
const MAX_SAFARI_DECODE_BYTES = 2146435072;
|
|
let numBytesDecoded = 0;
|
|
function decodeText(ptr, len) {
|
|
numBytesDecoded += len;
|
|
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
|
|
cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
cachedTextDecoder.decode();
|
|
numBytesDecoded = len;
|
|
}
|
|
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
}
|
|
|
|
const cachedTextEncoder = new TextEncoder();
|
|
|
|
if (!('encodeInto' in cachedTextEncoder)) {
|
|
cachedTextEncoder.encodeInto = function (arg, view) {
|
|
const buf = cachedTextEncoder.encode(arg);
|
|
view.set(buf);
|
|
return {
|
|
read: arg.length,
|
|
written: buf.length
|
|
};
|
|
}
|
|
}
|
|
|
|
let WASM_VECTOR_LEN = 0;
|
|
|
|
function wasm_bindgen__convert__closures_____invoke__h8c81ca6cba4eba00(arg0, arg1, arg2) {
|
|
wasm.wasm_bindgen__convert__closures_____invoke__h8c81ca6cba4eba00(arg0, arg1, arg2);
|
|
}
|
|
|
|
function wasm_bindgen__convert__closures_____invoke__h9a454594a18d3e6f(arg0, arg1, arg2) {
|
|
wasm.wasm_bindgen__convert__closures_____invoke__h9a454594a18d3e6f(arg0, arg1, arg2);
|
|
}
|
|
|
|
function wasm_bindgen__convert__closures_____invoke__h094c87b54a975e5a(arg0, arg1, arg2, arg3) {
|
|
wasm.wasm_bindgen__convert__closures_____invoke__h094c87b54a975e5a(arg0, arg1, arg2, arg3);
|
|
}
|
|
|
|
const AdaptiveSecurityFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_adaptivesecurity_free(ptr >>> 0, 1));
|
|
|
|
const AdversarialSimulatorFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_adversarialsimulator_free(ptr >>> 0, 1));
|
|
|
|
const AuditLogFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_auditlog_free(ptr >>> 0, 1));
|
|
|
|
const BrowserFingerprintFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_browserfingerprint_free(ptr >>> 0, 1));
|
|
|
|
const ByzantineDetectorFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_byzantinedetector_free(ptr >>> 0, 1));
|
|
|
|
const CoherenceEngineFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_coherenceengine_free(ptr >>> 0, 1));
|
|
|
|
const CollectiveMemoryFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_collectivememory_free(ptr >>> 0, 1));
|
|
|
|
const ContributionStreamFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_contributionstream_free(ptr >>> 0, 1));
|
|
|
|
const DifferentialPrivacyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_differentialprivacy_free(ptr >>> 0, 1));
|
|
|
|
const DriftTrackerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_drifttracker_free(ptr >>> 0, 1));
|
|
|
|
const EconomicEngineFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_economicengine_free(ptr >>> 0, 1));
|
|
|
|
const EconomicHealthFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_economichealth_free(ptr >>> 0, 1));
|
|
|
|
const EdgeNetConfigFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_edgenetconfig_free(ptr >>> 0, 1));
|
|
|
|
const EdgeNetNodeFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_edgenetnode_free(ptr >>> 0, 1));
|
|
|
|
const EntropyConsensusFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_entropyconsensus_free(ptr >>> 0, 1));
|
|
|
|
const EventLogFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_eventlog_free(ptr >>> 0, 1));
|
|
|
|
const EvolutionEngineFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_evolutionengine_free(ptr >>> 0, 1));
|
|
|
|
const FederatedModelFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_federatedmodel_free(ptr >>> 0, 1));
|
|
|
|
const FoundingRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_foundingregistry_free(ptr >>> 0, 1));
|
|
|
|
const GenesisKeyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_genesiskey_free(ptr >>> 0, 1));
|
|
|
|
const GenesisSunsetFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_genesissunset_free(ptr >>> 0, 1));
|
|
|
|
const GradientGossipFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_gradientgossip_free(ptr >>> 0, 1));
|
|
|
|
const ModelConsensusManagerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_modelconsensusmanager_free(ptr >>> 0, 1));
|
|
|
|
const MultiHeadAttentionFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_multiheadattention_free(ptr >>> 0, 1));
|
|
|
|
const NetworkEventsFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_networkevents_free(ptr >>> 0, 1));
|
|
|
|
const NetworkLearningFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_networklearning_free(ptr >>> 0, 1));
|
|
|
|
const NetworkTopologyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_networktopology_free(ptr >>> 0, 1));
|
|
|
|
const NodeConfigFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_nodeconfig_free(ptr >>> 0, 1));
|
|
|
|
const NodeStatsFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_nodestats_free(ptr >>> 0, 1));
|
|
|
|
const OptimizationEngineFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_optimizationengine_free(ptr >>> 0, 1));
|
|
|
|
const PiKeyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_pikey_free(ptr >>> 0, 1));
|
|
|
|
const QDAGLedgerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_qdagledger_free(ptr >>> 0, 1));
|
|
|
|
const QuarantineManagerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_quarantinemanager_free(ptr >>> 0, 1));
|
|
|
|
const RacEconomicEngineFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_raceconomicengine_free(ptr >>> 0, 1));
|
|
|
|
const RacSemanticRouterFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_racsemanticrouter_free(ptr >>> 0, 1));
|
|
|
|
const RateLimiterFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_ratelimiter_free(ptr >>> 0, 1));
|
|
|
|
const ReasoningBankFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_reasoningbank_free(ptr >>> 0, 1));
|
|
|
|
const ReputationManagerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_reputationmanager_free(ptr >>> 0, 1));
|
|
|
|
const ReputationSystemFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_reputationsystem_free(ptr >>> 0, 1));
|
|
|
|
const RewardDistributionFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_rewarddistribution_free(ptr >>> 0, 1));
|
|
|
|
const RewardManagerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_rewardmanager_free(ptr >>> 0, 1));
|
|
|
|
const SemanticRouterFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_semanticrouter_free(ptr >>> 0, 1));
|
|
|
|
const SessionKeyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_sessionkey_free(ptr >>> 0, 1));
|
|
|
|
const SpikeDrivenAttentionFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_spikedrivenattention_free(ptr >>> 0, 1));
|
|
|
|
const SpotCheckerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_spotchecker_free(ptr >>> 0, 1));
|
|
|
|
const StakeManagerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_stakemanager_free(ptr >>> 0, 1));
|
|
|
|
const SwarmIntelligenceFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_swarmintelligence_free(ptr >>> 0, 1));
|
|
|
|
const SybilDefenseFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_sybildefense_free(ptr >>> 0, 1));
|
|
|
|
const TopKSparsifierFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_topksparsifier_free(ptr >>> 0, 1));
|
|
|
|
const TrajectoryTrackerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_trajectorytracker_free(ptr >>> 0, 1));
|
|
|
|
const WasmAdapterPoolFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmadapterpool_free(ptr >>> 0, 1));
|
|
|
|
const WasmCapabilitiesFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmcapabilities_free(ptr >>> 0, 1));
|
|
|
|
const WasmCreditLedgerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmcreditledger_free(ptr >>> 0, 1));
|
|
|
|
const WasmIdleDetectorFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmidledetector_free(ptr >>> 0, 1));
|
|
|
|
const WasmMcpBroadcastFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmmcpbroadcast_free(ptr >>> 0, 1));
|
|
|
|
const WasmMcpServerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmmcpserver_free(ptr >>> 0, 1));
|
|
|
|
const WasmMcpTransportFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmmcptransport_free(ptr >>> 0, 1));
|
|
|
|
const WasmMcpWorkerHandlerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmmcpworkerhandler_free(ptr >>> 0, 1));
|
|
|
|
const WasmNetworkManagerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmnetworkmanager_free(ptr >>> 0, 1));
|
|
|
|
const WasmNodeIdentityFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmnodeidentity_free(ptr >>> 0, 1));
|
|
|
|
const WasmStigmergyFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmstigmergy_free(ptr >>> 0, 1));
|
|
|
|
const WasmTaskExecutorFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmtaskexecutor_free(ptr >>> 0, 1));
|
|
|
|
const WasmTaskQueueFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmtaskqueue_free(ptr >>> 0, 1));
|
|
|
|
const WasmWorkSchedulerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_wasmworkscheduler_free(ptr >>> 0, 1));
|
|
|
|
const WitnessTrackerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
? { register: () => {}, unregister: () => {} }
|
|
: new FinalizationRegistry(ptr => wasm.__wbg_witnesstracker_free(ptr >>> 0, 1));
|
|
|
|
/**
|
|
* Self-learning security system with Q-learning adaptive optimization
|
|
*/
|
|
export class AdaptiveSecurity {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
AdaptiveSecurityFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_adaptivesecurity_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Choose action using epsilon-greedy policy
|
|
* @param {string} state
|
|
* @param {string} available_actions
|
|
* @returns {string}
|
|
*/
|
|
chooseAction(state, available_actions) {
|
|
let deferred3_0;
|
|
let deferred3_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(state, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(available_actions, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.adaptivesecurity_chooseAction(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
deferred3_0 = ret[0];
|
|
deferred3_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Detect if request matches known attack pattern
|
|
* @param {Float32Array} features
|
|
* @returns {number}
|
|
*/
|
|
detectAttack(features) {
|
|
const ptr0 = passArrayF32ToWasm0(features, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.adaptivesecurity_detectAttack(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Export learned patterns for persistence
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportPatterns() {
|
|
const ret = wasm.adaptivesecurity_exportPatterns(this.__wbg_ptr);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Import learned patterns
|
|
* @param {Uint8Array} data
|
|
*/
|
|
importPatterns(data) {
|
|
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.adaptivesecurity_importPatterns(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getMinReputation() {
|
|
const ret = wasm.adaptivesecurity_getMinReputation(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getRateLimitMax() {
|
|
const ret = wasm.adaptivesecurity_getRateLimitMax(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getSecurityLevel() {
|
|
const ret = wasm.adaptivesecurity_getSecurityLevel(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get current adaptive thresholds
|
|
* @returns {bigint}
|
|
*/
|
|
getRateLimitWindow() {
|
|
const ret = wasm.adaptivesecurity_getRateLimitWindow(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Record attack pattern for learning
|
|
* @param {string} pattern_type
|
|
* @param {Float32Array} features
|
|
* @param {number} severity
|
|
*/
|
|
recordAttackPattern(pattern_type, features, severity) {
|
|
const ptr0 = passStringToWasm0(pattern_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArrayF32ToWasm0(features, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.adaptivesecurity_recordAttackPattern(this.__wbg_ptr, ptr0, len0, ptr1, len1, severity);
|
|
}
|
|
/**
|
|
* Update network health metrics
|
|
* @param {number} active_nodes
|
|
* @param {number} suspicious_nodes
|
|
* @param {number} attacks_hour
|
|
* @param {number} false_positives
|
|
* @param {number} avg_response_ms
|
|
*/
|
|
updateNetworkHealth(active_nodes, suspicious_nodes, attacks_hour, false_positives, avg_response_ms) {
|
|
wasm.adaptivesecurity_updateNetworkHealth(this.__wbg_ptr, active_nodes, suspicious_nodes, attacks_hour, false_positives, avg_response_ms);
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getSpotCheckProbability() {
|
|
const ret = wasm.adaptivesecurity_getSpotCheckProbability(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
constructor() {
|
|
const ret = wasm.adaptivesecurity_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
AdaptiveSecurityFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Learn from security event outcome (batched for better performance)
|
|
* @param {string} state
|
|
* @param {string} action
|
|
* @param {number} reward
|
|
* @param {string} next_state
|
|
*/
|
|
learn(state, action, reward, next_state) {
|
|
const ptr0 = passStringToWasm0(state, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passStringToWasm0(next_state, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
wasm.adaptivesecurity_learn(this.__wbg_ptr, ptr0, len0, ptr1, len1, reward, ptr2, len2);
|
|
}
|
|
/**
|
|
* Get learning statistics
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adaptivesecurity_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) AdaptiveSecurity.prototype[Symbol.dispose] = AdaptiveSecurity.prototype.free;
|
|
|
|
/**
|
|
* Adversarial testing framework
|
|
*/
|
|
export class AdversarialSimulator {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
AdversarialSimulatorFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_adversarialsimulator_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Simulate DDoS attack
|
|
* @param {number} requests_per_second
|
|
* @param {bigint} duration_ms
|
|
* @returns {string}
|
|
*/
|
|
simulateDDoS(requests_per_second, duration_ms) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_simulateDDoS(this.__wbg_ptr, requests_per_second, duration_ms);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Simulate Sybil attack
|
|
* @param {number} fake_nodes
|
|
* @param {boolean} same_fingerprint
|
|
* @returns {string}
|
|
*/
|
|
simulateSybil(fake_nodes, same_fingerprint) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_simulateSybil(this.__wbg_ptr, fake_nodes, same_fingerprint);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Enable chaos mode for continuous testing
|
|
* @param {boolean} enabled
|
|
*/
|
|
enableChaosMode(enabled) {
|
|
wasm.adversarialsimulator_enableChaosMode(this.__wbg_ptr, enabled);
|
|
}
|
|
/**
|
|
* Run comprehensive security audit
|
|
* @returns {string}
|
|
*/
|
|
runSecurityAudit() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_runSecurityAudit(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Simulate Byzantine node behavior
|
|
* @param {number} byzantine_nodes
|
|
* @param {number} total_nodes
|
|
* @returns {string}
|
|
*/
|
|
simulateByzantine(byzantine_nodes, total_nodes) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_simulateByzantine(this.__wbg_ptr, byzantine_nodes, total_nodes);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get defence metrics
|
|
* @returns {string}
|
|
*/
|
|
getDefenceMetrics() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_getDefenceMetrics(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get recommendations based on testing
|
|
* @returns {string}
|
|
*/
|
|
getRecommendations() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_getRecommendations(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Generate chaos event
|
|
* @returns {string | undefined}
|
|
*/
|
|
generateChaosEvent() {
|
|
const ret = wasm.adversarialsimulator_generateChaosEvent(this.__wbg_ptr);
|
|
let v1;
|
|
if (ret[0] !== 0) {
|
|
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
}
|
|
return v1;
|
|
}
|
|
/**
|
|
* Simulate free-riding attack
|
|
* @param {number} consumption_rate
|
|
* @param {number} contribution_rate
|
|
* @returns {string}
|
|
*/
|
|
simulateFreeRiding(consumption_rate, contribution_rate) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_simulateFreeRiding(this.__wbg_ptr, consumption_rate, contribution_rate);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Simulate double-spend attempt
|
|
* @param {bigint} amount
|
|
* @param {number} concurrent_targets
|
|
* @returns {string}
|
|
*/
|
|
simulateDoubleSpend(amount, concurrent_targets) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_simulateDoubleSpend(this.__wbg_ptr, amount, concurrent_targets);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Simulate result tampering
|
|
* @param {number} tamper_percentage
|
|
* @returns {string}
|
|
*/
|
|
simulateResultTampering(tamper_percentage) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.adversarialsimulator_simulateResultTampering(this.__wbg_ptr, tamper_percentage);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
constructor() {
|
|
const ret = wasm.adversarialsimulator_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
AdversarialSimulatorFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) AdversarialSimulator.prototype[Symbol.dispose] = AdversarialSimulator.prototype.free;
|
|
|
|
/**
|
|
* Audit logger for security events
|
|
*/
|
|
export class AuditLog {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
AuditLogFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_auditlog_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Export events as JSON
|
|
* @returns {string}
|
|
*/
|
|
exportEvents() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.auditlog_exportEvents(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get events for a node
|
|
* @param {string} node_id
|
|
* @returns {number}
|
|
*/
|
|
getEventsForNode(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.auditlog_getEventsForNode(this.__wbg_ptr, ptr0, len0);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get events by severity
|
|
* @param {number} min_severity
|
|
* @returns {number}
|
|
*/
|
|
getEventsBySeverity(min_severity) {
|
|
const ret = wasm.auditlog_getEventsBySeverity(this.__wbg_ptr, min_severity);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Log an event
|
|
* @param {string} event_type
|
|
* @param {string} node_id
|
|
* @param {string} details
|
|
* @param {number} severity
|
|
*/
|
|
log(event_type, node_id, details, severity) {
|
|
const ptr0 = passStringToWasm0(event_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passStringToWasm0(details, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
wasm.auditlog_log(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, severity);
|
|
}
|
|
constructor() {
|
|
const ret = wasm.auditlog_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
AuditLogFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) AuditLog.prototype[Symbol.dispose] = AuditLog.prototype.free;
|
|
|
|
/**
|
|
* Browser fingerprint generator for anti-sybil protection
|
|
*/
|
|
export class BrowserFingerprint {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
BrowserFingerprintFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_browserfingerprint_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Generate anonymous uniqueness score
|
|
* This doesn't track users, just ensures one node per browser
|
|
* @returns {Promise<string>}
|
|
*/
|
|
static generate() {
|
|
const ret = wasm.browserfingerprint_generate();
|
|
return ret;
|
|
}
|
|
}
|
|
if (Symbol.dispose) BrowserFingerprint.prototype[Symbol.dispose] = BrowserFingerprint.prototype.free;
|
|
|
|
/**
|
|
* Byzantine gradient detection using statistical methods
|
|
*/
|
|
export class ByzantineDetector {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
ByzantineDetectorFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_byzantinedetector_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get maximum allowed magnitude
|
|
* @returns {number}
|
|
*/
|
|
getMaxMagnitude() {
|
|
const ret = wasm.byzantinedetector_getMaxMagnitude(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Create a new Byzantine detector
|
|
* @param {number} max_magnitude
|
|
* @param {number} zscore_threshold
|
|
*/
|
|
constructor(max_magnitude, zscore_threshold) {
|
|
const ret = wasm.byzantinedetector_new(max_magnitude, zscore_threshold);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
ByzantineDetectorFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) ByzantineDetector.prototype[Symbol.dispose] = ByzantineDetector.prototype.free;
|
|
|
|
/**
|
|
* The main coherence engine running the RAC protocol
|
|
*/
|
|
export class CoherenceEngine {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
CoherenceEngineFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_coherenceengine_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get event log length
|
|
* @returns {number}
|
|
*/
|
|
eventCount() {
|
|
const ret = wasm.coherenceengine_eventCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Check if context has drifted
|
|
* @param {string} context_hex
|
|
* @returns {boolean}
|
|
*/
|
|
hasDrifted(context_hex) {
|
|
const ptr0 = passStringToWasm0(context_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.coherenceengine_hasDrifted(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Check if a claim can be used in decisions
|
|
* @param {string} claim_id
|
|
* @returns {boolean}
|
|
*/
|
|
canUseClaim(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.coherenceengine_canUseClaim(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get witness count for a claim
|
|
* @param {string} claim_id
|
|
* @returns {number}
|
|
*/
|
|
witnessCount(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.coherenceengine_witnessCount(this.__wbg_ptr, ptr0, len0);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get conflict count
|
|
* @returns {number}
|
|
*/
|
|
conflictCount() {
|
|
const ret = wasm.coherenceengine_conflictCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get current Merkle root
|
|
* @returns {string}
|
|
*/
|
|
getMerkleRoot() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.coherenceengine_getMerkleRoot(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get quarantined claim count
|
|
* @returns {number}
|
|
*/
|
|
quarantinedCount() {
|
|
const ret = wasm.coherenceengine_quarantinedCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Check quarantine level for a claim
|
|
* @param {string} claim_id
|
|
* @returns {number}
|
|
*/
|
|
getQuarantineLevel(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.coherenceengine_getQuarantineLevel(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if claim has sufficient witnesses
|
|
* @param {string} claim_id
|
|
* @returns {boolean}
|
|
*/
|
|
hasSufficientWitnesses(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.coherenceengine_hasSufficientWitnesses(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Create a new coherence engine
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.coherenceengine_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
CoherenceEngineFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get drift for a context
|
|
* @param {string} context_hex
|
|
* @returns {number}
|
|
*/
|
|
getDrift(context_hex) {
|
|
const ptr0 = passStringToWasm0(context_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.coherenceengine_getDrift(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.coherenceengine_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) CoherenceEngine.prototype[Symbol.dispose] = CoherenceEngine.prototype.free;
|
|
|
|
/**
|
|
* Collective memory system for distributed pattern learning
|
|
*/
|
|
export class CollectiveMemory {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
CollectiveMemoryFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_collectivememory_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get queue size
|
|
* @returns {number}
|
|
*/
|
|
queueSize() {
|
|
const ret = wasm.collectivememory_queueSize(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Run consolidation (call during idle periods)
|
|
* @returns {number}
|
|
*/
|
|
consolidate() {
|
|
const ret = wasm.collectivememory_consolidate(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Check if a pattern ID exists
|
|
* @param {string} pattern_id
|
|
* @returns {boolean}
|
|
*/
|
|
hasPattern(pattern_id) {
|
|
const ptr0 = passStringToWasm0(pattern_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.collectivememory_hasPattern(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get pattern count in shared index
|
|
* @returns {number}
|
|
*/
|
|
patternCount() {
|
|
const ret = wasm.collectivememory_patternCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create new collective memory with default config
|
|
* @param {string} node_id
|
|
*/
|
|
constructor(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.collectivememory_new(ptr0, len0);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
CollectiveMemoryFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Search for similar patterns
|
|
* @param {string} query_json
|
|
* @param {number} k
|
|
* @returns {string}
|
|
*/
|
|
search(query_json, k) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.collectivememory_search(this.__wbg_ptr, ptr0, len0, k);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.collectivememory_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) CollectiveMemory.prototype[Symbol.dispose] = CollectiveMemory.prototype.free;
|
|
|
|
/**
|
|
* Contribution stream for sustained development
|
|
*/
|
|
export class ContributionStream {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
ContributionStreamFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_contributionstream_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if streams are healthy
|
|
* @returns {boolean}
|
|
*/
|
|
isHealthy() {
|
|
const ret = wasm.contributionstream_isHealthy(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Process network fee distribution
|
|
* @param {bigint} total_fees
|
|
* @param {bigint} epoch
|
|
* @returns {bigint}
|
|
*/
|
|
processFees(total_fees, epoch) {
|
|
const ret = wasm.contributionstream_processFees(this.__wbg_ptr, total_fees, epoch);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get total distributed
|
|
* @returns {bigint}
|
|
*/
|
|
getTotalDistributed() {
|
|
const ret = wasm.contributionstream_getTotalDistributed(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
constructor() {
|
|
const ret = wasm.contributionstream_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
ContributionStreamFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) ContributionStream.prototype[Symbol.dispose] = ContributionStream.prototype.free;
|
|
|
|
/**
|
|
* Differential privacy noise generator
|
|
*/
|
|
export class DifferentialPrivacy {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
DifferentialPrivacyFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_differentialprivacy_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if DP is enabled
|
|
* @returns {boolean}
|
|
*/
|
|
isEnabled() {
|
|
const ret = wasm.differentialprivacy_isEnabled(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get epsilon value
|
|
* @returns {number}
|
|
*/
|
|
getEpsilon() {
|
|
const ret = wasm.differentialprivacy_getEpsilon(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Enable/disable differential privacy
|
|
* @param {boolean} enabled
|
|
*/
|
|
setEnabled(enabled) {
|
|
wasm.differentialprivacy_setEnabled(this.__wbg_ptr, enabled);
|
|
}
|
|
/**
|
|
* Create a new differential privacy module
|
|
* @param {number} epsilon
|
|
* @param {number} sensitivity
|
|
*/
|
|
constructor(epsilon, sensitivity) {
|
|
const ret = wasm.differentialprivacy_new(epsilon, sensitivity);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
DifferentialPrivacyFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) DifferentialPrivacy.prototype[Symbol.dispose] = DifferentialPrivacy.prototype.free;
|
|
|
|
/**
|
|
* Manages semantic drift tracking
|
|
*/
|
|
export class DriftTracker {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
DriftTrackerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_drifttracker_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if context has drifted beyond threshold
|
|
* @param {string} context_hex
|
|
* @returns {boolean}
|
|
*/
|
|
hasDrifted(context_hex) {
|
|
const ptr0 = passStringToWasm0(context_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.drifttracker_hasDrifted(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get contexts with significant drift
|
|
* @returns {string}
|
|
*/
|
|
getDriftedContexts() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.drifttracker_getDriftedContexts(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Create a new drift tracker
|
|
* @param {number} drift_threshold
|
|
*/
|
|
constructor(drift_threshold) {
|
|
const ret = wasm.drifttracker_new(drift_threshold);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
DriftTrackerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get drift for a context
|
|
* @param {string} context_hex
|
|
* @returns {number}
|
|
*/
|
|
getDrift(context_hex) {
|
|
const ptr0 = passStringToWasm0(context_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.drifttracker_getDrift(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
}
|
|
if (Symbol.dispose) DriftTracker.prototype[Symbol.dispose] = DriftTracker.prototype.free;
|
|
|
|
/**
|
|
* Economic distribution system for sustainable operations
|
|
*/
|
|
export class EconomicEngine {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EconomicEngineFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_economicengine_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get economic health status
|
|
* @returns {EconomicHealth}
|
|
*/
|
|
getHealth() {
|
|
const ret = wasm.economicengine_getHealth(this.__wbg_ptr);
|
|
return EconomicHealth.__wrap(ret);
|
|
}
|
|
/**
|
|
* Get treasury balance
|
|
* @returns {bigint}
|
|
*/
|
|
getTreasury() {
|
|
const ret = wasm.economicengine_getTreasury(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Advance to next epoch
|
|
*/
|
|
advanceEpoch() {
|
|
wasm.economicengine_advanceEpoch(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Process task completion and distribute rewards
|
|
* @param {bigint} base_amount
|
|
* @param {number} multiplier
|
|
* @returns {RewardDistribution}
|
|
*/
|
|
processReward(base_amount, multiplier) {
|
|
const ret = wasm.economicengine_processReward(this.__wbg_ptr, base_amount, multiplier);
|
|
return RewardDistribution.__wrap(ret);
|
|
}
|
|
/**
|
|
* Get protocol fund balance (for development sustainability)
|
|
* @returns {bigint}
|
|
*/
|
|
getProtocolFund() {
|
|
const ret = wasm.economicengine_getProtocolFund(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Check if network can sustain itself
|
|
* @param {number} active_nodes
|
|
* @param {bigint} daily_tasks
|
|
* @returns {boolean}
|
|
*/
|
|
isSelfSustaining(active_nodes, daily_tasks) {
|
|
const ret = wasm.economicengine_isSelfSustaining(this.__wbg_ptr, active_nodes, daily_tasks);
|
|
return ret !== 0;
|
|
}
|
|
constructor() {
|
|
const ret = wasm.economicengine_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
EconomicEngineFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) EconomicEngine.prototype[Symbol.dispose] = EconomicEngine.prototype.free;
|
|
|
|
export class EconomicHealth {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(EconomicHealth.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
EconomicHealthFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EconomicHealthFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_economichealth_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Velocity of rUv (transactions per period)
|
|
* @returns {number}
|
|
*/
|
|
get velocity() {
|
|
const ret = wasm.__wbg_get_economichealth_velocity(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Velocity of rUv (transactions per period)
|
|
* @param {number} arg0
|
|
*/
|
|
set velocity(arg0) {
|
|
wasm.__wbg_set_economichealth_velocity(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Network utilization rate
|
|
* @returns {number}
|
|
*/
|
|
get utilization() {
|
|
const ret = wasm.__wbg_get_economichealth_utilization(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Network utilization rate
|
|
* @param {number} arg0
|
|
*/
|
|
set utilization(arg0) {
|
|
wasm.__wbg_set_economichealth_utilization(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Supply growth rate
|
|
* @returns {number}
|
|
*/
|
|
get growth_rate() {
|
|
const ret = wasm.__wbg_get_economichealth_growth_rate(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Supply growth rate
|
|
* @param {number} arg0
|
|
*/
|
|
set growth_rate(arg0) {
|
|
wasm.__wbg_set_economichealth_growth_rate(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Stability index (0-1)
|
|
* @returns {number}
|
|
*/
|
|
get stability() {
|
|
const ret = wasm.__wbg_get_economichealth_stability(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Stability index (0-1)
|
|
* @param {number} arg0
|
|
*/
|
|
set stability(arg0) {
|
|
wasm.__wbg_set_economichealth_stability(this.__wbg_ptr, arg0);
|
|
}
|
|
}
|
|
if (Symbol.dispose) EconomicHealth.prototype[Symbol.dispose] = EconomicHealth.prototype.free;
|
|
|
|
/**
|
|
* Configuration builder for EdgeNet
|
|
*/
|
|
export class EdgeNetConfig {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(EdgeNetConfig.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
EdgeNetConfigFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EdgeNetConfigFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_edgenetconfig_free(ptr, 0);
|
|
}
|
|
/**
|
|
* @param {number} bytes
|
|
* @returns {EdgeNetConfig}
|
|
*/
|
|
memoryLimit(bytes) {
|
|
const ptr = this.__destroy_into_raw();
|
|
const ret = wasm.edgenetconfig_memoryLimit(ptr, bytes);
|
|
return EdgeNetConfig.__wrap(ret);
|
|
}
|
|
/**
|
|
* @param {number} ms
|
|
* @returns {EdgeNetConfig}
|
|
*/
|
|
minIdleTime(ms) {
|
|
const ptr = this.__destroy_into_raw();
|
|
const ret = wasm.edgenetconfig_minIdleTime(ptr, ms);
|
|
return EdgeNetConfig.__wrap(ret);
|
|
}
|
|
/**
|
|
* @param {boolean} respect
|
|
* @returns {EdgeNetConfig}
|
|
*/
|
|
respectBattery(respect) {
|
|
const ptr = this.__destroy_into_raw();
|
|
const ret = wasm.edgenetconfig_respectBattery(ptr, respect);
|
|
return EdgeNetConfig.__wrap(ret);
|
|
}
|
|
/**
|
|
* @param {string} site_id
|
|
*/
|
|
constructor(site_id) {
|
|
const ptr0 = passStringToWasm0(site_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetconfig_new(ptr0, len0);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
EdgeNetConfigFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* @returns {EdgeNetNode}
|
|
*/
|
|
build() {
|
|
const ptr = this.__destroy_into_raw();
|
|
const ret = wasm.edgenetconfig_build(ptr);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return EdgeNetNode.__wrap(ret[0]);
|
|
}
|
|
/**
|
|
* @param {string} url
|
|
* @returns {EdgeNetConfig}
|
|
*/
|
|
addRelay(url) {
|
|
const ptr = this.__destroy_into_raw();
|
|
const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetconfig_addRelay(ptr, ptr0, len0);
|
|
return EdgeNetConfig.__wrap(ret);
|
|
}
|
|
/**
|
|
* @param {number} limit
|
|
* @returns {EdgeNetConfig}
|
|
*/
|
|
cpuLimit(limit) {
|
|
const ptr = this.__destroy_into_raw();
|
|
const ret = wasm.edgenetconfig_cpuLimit(ptr, limit);
|
|
return EdgeNetConfig.__wrap(ret);
|
|
}
|
|
}
|
|
if (Symbol.dispose) EdgeNetConfig.prototype[Symbol.dispose] = EdgeNetConfig.prototype.free;
|
|
|
|
/**
|
|
* Main EdgeNet node - the entry point for participating in the network
|
|
*/
|
|
export class EdgeNetNode {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(EdgeNetNode.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
EdgeNetNodeFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EdgeNetNodeFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_edgenetnode_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Disconnect from the network
|
|
*/
|
|
disconnect() {
|
|
const ret = wasm.edgenetnode_disconnect(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Enable HDC for hyperdimensional computing
|
|
* @returns {boolean}
|
|
*/
|
|
enableHDC() {
|
|
const ret = wasm.edgenetnode_enableHDC(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Enable Neural Autonomous Organization for governance
|
|
* @param {number} quorum
|
|
* @returns {boolean}
|
|
*/
|
|
enableNAO(quorum) {
|
|
const ret = wasm.edgenetnode_enableNAO(this.__wbg_ptr, quorum);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Enable WTA for instant decisions
|
|
* @param {number} num_neurons
|
|
* @returns {boolean}
|
|
*/
|
|
enableWTA(num_neurons) {
|
|
const ret = wasm.edgenetnode_enableBTSP(this.__wbg_ptr, num_neurons);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Enable BTSP for one-shot learning
|
|
* @param {number} input_dim
|
|
* @returns {boolean}
|
|
*/
|
|
enableBTSP(input_dim) {
|
|
const ret = wasm.edgenetnode_enableBTSP(this.__wbg_ptr, input_dim);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Propose an action in the NAO
|
|
* @param {string} action
|
|
* @returns {string}
|
|
*/
|
|
proposeNAO(action) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_proposeNAO(this.__wbg_ptr, ptr0, len0);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Alias for creditBalance - returns rUv balance
|
|
* @returns {bigint}
|
|
*/
|
|
ruvBalance() {
|
|
const ret = wasm.edgenetnode_creditBalance(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Submit a task to the network
|
|
* @param {string} task_type
|
|
* @param {Uint8Array} payload
|
|
* @param {bigint} max_credits
|
|
* @returns {Promise<any>}
|
|
*/
|
|
submitTask(task_type, payload, max_credits) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_submitTask(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_credits);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check for active celebration events
|
|
* @returns {string}
|
|
*/
|
|
checkEvents() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_checkEvents(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get current throttle level (0.0 - 1.0)
|
|
* @returns {number}
|
|
*/
|
|
getThrottle() {
|
|
const ret = wasm.edgenetnode_getThrottle(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get treasury balance for operations
|
|
* @returns {bigint}
|
|
*/
|
|
getTreasury() {
|
|
const ret = wasm.edgenetnode_getTreasury(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Check if a claim can be used (not quarantined)
|
|
* @param {string} claim_id
|
|
* @returns {boolean}
|
|
*/
|
|
canUseClaim(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_canUseClaim(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Process epoch for economic distribution
|
|
*/
|
|
processEpoch() {
|
|
wasm.edgenetnode_processEpoch(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Store a learned pattern in the reasoning bank
|
|
* @param {string} pattern_json
|
|
* @returns {number}
|
|
*/
|
|
storePattern(pattern_json) {
|
|
const ptr0 = passStringToWasm0(pattern_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_storePattern(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get current rUv (Resource Utility Voucher) balance
|
|
* @returns {bigint}
|
|
*/
|
|
creditBalance() {
|
|
const ret = wasm.edgenetnode_creditBalance(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get motivational message (subtle Easter egg)
|
|
* @returns {string}
|
|
*/
|
|
getMotivation() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getMotivation(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get current contribution multiplier based on network size
|
|
* @returns {number}
|
|
*/
|
|
getMultiplier() {
|
|
const ret = wasm.edgenetnode_getMultiplier(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Prune low-quality learned patterns
|
|
* @param {number} min_usage
|
|
* @param {number} min_confidence
|
|
* @returns {number}
|
|
*/
|
|
prunePatterns(min_usage, min_confidence) {
|
|
const ret = wasm.edgenetnode_prunePatterns(this.__wbg_ptr, min_usage, min_confidence);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get current Merkle root for audit (Axiom 11: Equivocation detectable)
|
|
* @returns {string}
|
|
*/
|
|
getMerkleRoot() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getMerkleRoot(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Lookup similar patterns for task optimization
|
|
* @param {string} query_json
|
|
* @param {number} k
|
|
* @returns {string}
|
|
*/
|
|
lookupPatterns(query_json, k) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_lookupPatterns(this.__wbg_ptr, ptr0, len0, k);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get all available exotic capabilities and their status
|
|
* @returns {any}
|
|
*/
|
|
getCapabilities() {
|
|
const ret = wasm.edgenetnode_getCapabilities(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if this node should replicate (high performer)
|
|
* @returns {boolean}
|
|
*/
|
|
shouldReplicate() {
|
|
const ret = wasm.edgenetnode_shouldReplicate(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Enable MicroLoRA for self-learning
|
|
* @param {number} rank
|
|
* @returns {boolean}
|
|
*/
|
|
enableMicroLoRA(rank) {
|
|
const ret = wasm.edgenetnode_enableBTSP(this.__wbg_ptr, rank);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get founding contributor count
|
|
* @returns {number}
|
|
*/
|
|
getFounderCount() {
|
|
const ret = wasm.edgenetnode_getFounderCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get optimal peers for task routing
|
|
* @param {number} count
|
|
* @returns {string[]}
|
|
*/
|
|
getOptimalPeers(count) {
|
|
const ret = wasm.edgenetnode_getOptimalPeers(this.__wbg_ptr, count);
|
|
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Get stored pattern count
|
|
* @returns {number}
|
|
*/
|
|
getPatternCount() {
|
|
const ret = wasm.edgenetnode_getPatternCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get protocol development fund balance
|
|
* @returns {bigint}
|
|
*/
|
|
getProtocolFund() {
|
|
const ret = wasm.edgenetnode_getProtocolFund(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get themed network status
|
|
* @param {number} node_count
|
|
* @returns {string}
|
|
*/
|
|
getThemedStatus(node_count) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getThemedStatus(this.__wbg_ptr, node_count);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get contribution stream health
|
|
* @returns {boolean}
|
|
*/
|
|
isStreamHealthy() {
|
|
const ret = wasm.edgenetnode_isStreamHealthy(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Process the next available task (called by worker)
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
processNextTask() {
|
|
const ret = wasm.edgenetnode_processNextTask(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Step all exotic capabilities forward
|
|
* @param {number} dt
|
|
*/
|
|
stepCapabilities(dt) {
|
|
wasm.edgenetnode_stepCapabilities(this.__wbg_ptr, dt);
|
|
}
|
|
/**
|
|
* Get active conflict count (Axiom 6: Disagreement is signal)
|
|
* @returns {number}
|
|
*/
|
|
getConflictCount() {
|
|
const ret = wasm.edgenetnode_getConflictCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get learning statistics
|
|
* @returns {string}
|
|
*/
|
|
getLearningStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getLearningStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check if network is self-sustaining
|
|
* @param {number} active_nodes
|
|
* @param {bigint} daily_tasks
|
|
* @returns {boolean}
|
|
*/
|
|
isSelfSustaining(active_nodes, daily_tasks) {
|
|
const ret = wasm.edgenetnode_isSelfSustaining(this.__wbg_ptr, active_nodes, daily_tasks);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Record node performance for evolution
|
|
* @param {number} success_rate
|
|
* @param {number} throughput
|
|
*/
|
|
recordPerformance(success_rate, throughput) {
|
|
wasm.edgenetnode_recordPerformance(this.__wbg_ptr, success_rate, throughput);
|
|
}
|
|
/**
|
|
* Run security audit (adversarial testing)
|
|
* @returns {string}
|
|
*/
|
|
runSecurityAudit() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_runSecurityAudit(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Enable Time Crystal for P2P synchronization
|
|
* @param {number} oscillators
|
|
* @returns {boolean}
|
|
*/
|
|
enableTimeCrystal(oscillators) {
|
|
const ret = wasm.edgenetnode_enableBTSP(this.__wbg_ptr, oscillators);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get coherence statistics
|
|
* @returns {string}
|
|
*/
|
|
getCoherenceStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getCoherenceStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get economic health metrics
|
|
* @returns {string}
|
|
*/
|
|
getEconomicHealth() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getEconomicHealth(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get network fitness score (0-1)
|
|
* @returns {number}
|
|
*/
|
|
getNetworkFitness() {
|
|
const ret = wasm.edgenetnode_getNetworkFitness(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Record task routing outcome for optimization
|
|
* @param {string} task_type
|
|
* @param {string} node_id
|
|
* @param {bigint} latency_ms
|
|
* @param {boolean} success
|
|
*/
|
|
recordTaskRouting(task_type, node_id, latency_ms, success) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.edgenetnode_recordTaskRouting(this.__wbg_ptr, ptr0, len0, ptr1, len1, latency_ms, success);
|
|
}
|
|
/**
|
|
* Enable Morphogenetic Network for emergent topology
|
|
* @param {number} size
|
|
* @returns {boolean}
|
|
*/
|
|
enableMorphogenetic(size) {
|
|
const ret = wasm.edgenetnode_enableBTSP(this.__wbg_ptr, size);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get trajectory count for learning analysis
|
|
* @returns {number}
|
|
*/
|
|
getTrajectoryCount() {
|
|
const ret = wasm.edgenetnode_getTrajectoryCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get energy efficiency ratio from spike-driven attention
|
|
* @param {number} seq_len
|
|
* @param {number} hidden_dim
|
|
* @returns {number}
|
|
*/
|
|
getEnergyEfficiency(seq_len, hidden_dim) {
|
|
const ret = wasm.edgenetnode_getEnergyEfficiency(this.__wbg_ptr, seq_len, hidden_dim);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get quarantined claim count (Axiom 9: Quarantine is mandatory)
|
|
* @returns {number}
|
|
*/
|
|
getQuarantinedCount() {
|
|
const ret = wasm.edgenetnode_getQuarantinedCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get Time Crystal synchronization level (0.0 - 1.0)
|
|
* @returns {number}
|
|
*/
|
|
getTimeCrystalSync() {
|
|
const ret = wasm.edgenetnode_getTimeCrystalSync(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get optimization statistics
|
|
* @returns {string}
|
|
*/
|
|
getOptimizationStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getOptimizationStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get recommended configuration for new nodes
|
|
* @returns {string}
|
|
*/
|
|
getRecommendedConfig() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_getRecommendedConfig(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Enable Global Workspace for attention
|
|
* @param {number} capacity
|
|
* @returns {boolean}
|
|
*/
|
|
enableGlobalWorkspace(capacity) {
|
|
const ret = wasm.edgenetnode_enableBTSP(this.__wbg_ptr, capacity);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Record peer interaction for topology optimization
|
|
* @param {string} peer_id
|
|
* @param {number} success_rate
|
|
*/
|
|
recordPeerInteraction(peer_id, success_rate) {
|
|
const ptr0 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.edgenetnode_recordPeerInteraction(this.__wbg_ptr, ptr0, len0, success_rate);
|
|
}
|
|
/**
|
|
* Get capabilities summary as JSON
|
|
* @returns {any}
|
|
*/
|
|
getCapabilitiesSummary() {
|
|
const ret = wasm.edgenetnode_getCapabilitiesSummary(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get coherence engine event count
|
|
* @returns {number}
|
|
*/
|
|
getCoherenceEventCount() {
|
|
const ret = wasm.edgenetnode_getCoherenceEventCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get quarantine level for a claim
|
|
* @param {string} claim_id
|
|
* @returns {number}
|
|
*/
|
|
getClaimQuarantineLevel(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_getClaimQuarantineLevel(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Record a task execution trajectory for learning
|
|
* @param {string} trajectory_json
|
|
* @returns {boolean}
|
|
*/
|
|
recordLearningTrajectory(trajectory_json) {
|
|
const ptr0 = passStringToWasm0(trajectory_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_recordLearningTrajectory(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Create a new EdgeNet node
|
|
* @param {string} site_id
|
|
* @param {NodeConfig | null} [config]
|
|
*/
|
|
constructor(site_id, config) {
|
|
const ptr0 = passStringToWasm0(site_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
let ptr1 = 0;
|
|
if (!isLikeNone(config)) {
|
|
_assertClass(config, NodeConfig);
|
|
ptr1 = config.__destroy_into_raw();
|
|
}
|
|
const ret = wasm.edgenetnode_new(ptr0, len0, ptr1);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
EdgeNetNodeFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Pause contribution
|
|
*/
|
|
pause() {
|
|
wasm.edgenetnode_pause(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Start contributing to the network
|
|
*/
|
|
start() {
|
|
const ret = wasm.edgenetnode_start(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Resume contribution
|
|
*/
|
|
resume() {
|
|
wasm.edgenetnode_resume(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Check if user is currently idle
|
|
* @returns {boolean}
|
|
*/
|
|
isIdle() {
|
|
const ret = wasm.edgenetnode_isIdle(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get the node's unique identifier
|
|
* @returns {string}
|
|
*/
|
|
nodeId() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.edgenetnode_nodeId(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Vote on a NAO proposal
|
|
* @param {string} proposal_id
|
|
* @param {number} weight
|
|
* @returns {boolean}
|
|
*/
|
|
voteNAO(proposal_id, weight) {
|
|
const ptr0 = passStringToWasm0(proposal_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.edgenetnode_voteNAO(this.__wbg_ptr, ptr0, len0, weight);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get node statistics
|
|
* @returns {NodeStats}
|
|
*/
|
|
getStats() {
|
|
const ret = wasm.edgenetnode_getStats(this.__wbg_ptr);
|
|
return NodeStats.__wrap(ret);
|
|
}
|
|
}
|
|
if (Symbol.dispose) EdgeNetNode.prototype[Symbol.dispose] = EdgeNetNode.prototype.free;
|
|
|
|
/**
|
|
* Entropy-based consensus engine for swarm decisions
|
|
*/
|
|
export class EntropyConsensus {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(EntropyConsensus.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
EntropyConsensusFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EntropyConsensusFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_entropyconsensus_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get belief probability for a decision
|
|
* @param {bigint} decision_id
|
|
* @returns {number}
|
|
*/
|
|
getBelief(decision_id) {
|
|
const ret = wasm.entropyconsensus_getBelief(this.__wbg_ptr, decision_id);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get number of negotiation rounds completed
|
|
* @returns {number}
|
|
*/
|
|
getRounds() {
|
|
const ret = wasm.entropyconsensus_getRounds(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Set initial belief for a decision
|
|
* @param {bigint} decision_id
|
|
* @param {number} probability
|
|
*/
|
|
setBelief(decision_id, probability) {
|
|
wasm.entropyconsensus_setBelief(this.__wbg_ptr, decision_id, probability);
|
|
}
|
|
/**
|
|
* Get the winning decision (if converged)
|
|
* @returns {bigint | undefined}
|
|
*/
|
|
getDecision() {
|
|
const ret = wasm.entropyconsensus_getDecision(this.__wbg_ptr);
|
|
return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
|
|
}
|
|
/**
|
|
* Get number of decision options
|
|
* @returns {number}
|
|
*/
|
|
optionCount() {
|
|
const ret = wasm.entropyconsensus_optionCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Check if negotiation has timed out
|
|
* @returns {boolean}
|
|
*/
|
|
hasTimedOut() {
|
|
const ret = wasm.entropyconsensus_hasTimedOut(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Set belief without normalizing (for batch updates)
|
|
* Call normalize_beliefs() after all set_belief_raw calls
|
|
* @param {bigint} decision_id
|
|
* @param {number} probability
|
|
*/
|
|
set_belief_raw(decision_id, probability) {
|
|
wasm.entropyconsensus_set_belief_raw(this.__wbg_ptr, decision_id, probability);
|
|
}
|
|
/**
|
|
* Create with custom entropy threshold
|
|
* @param {number} threshold
|
|
* @returns {EntropyConsensus}
|
|
*/
|
|
static withThreshold(threshold) {
|
|
const ret = wasm.entropyconsensus_withThreshold(threshold);
|
|
return EntropyConsensus.__wrap(ret);
|
|
}
|
|
/**
|
|
* Get current temperature (for annealing)
|
|
* @returns {number}
|
|
*/
|
|
getTemperature() {
|
|
const ret = wasm.entropyconsensus_getTemperature(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Manually trigger normalization (for use after set_belief_raw)
|
|
*/
|
|
finalize_beliefs() {
|
|
wasm.entropyconsensus_finalize_beliefs(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Get entropy history as JSON
|
|
* @returns {string}
|
|
*/
|
|
getEntropyHistory() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.entropyconsensus_getEntropyHistory(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get the entropy threshold for convergence
|
|
* @returns {number}
|
|
*/
|
|
getEntropyThreshold() {
|
|
const ret = wasm.entropyconsensus_getEntropyThreshold(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Create new entropy consensus with default configuration
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.entropyconsensus_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
EntropyConsensusFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Reset consensus state for new decision
|
|
*/
|
|
reset() {
|
|
wasm.entropyconsensus_reset(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Get current entropy of belief distribution
|
|
* @returns {number}
|
|
*/
|
|
entropy() {
|
|
const ret = wasm.entropyconsensus_entropy(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if consensus has been reached
|
|
* @returns {boolean}
|
|
*/
|
|
converged() {
|
|
const ret = wasm.entropyconsensus_converged(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get consensus statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.entropyconsensus_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) EntropyConsensus.prototype[Symbol.dispose] = EntropyConsensus.prototype.free;
|
|
|
|
/**
|
|
* Append-only Merkle log for audit (FIXED: proper event storage)
|
|
*/
|
|
export class EventLog {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EventLogFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_eventlog_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get total event count
|
|
* @returns {number}
|
|
*/
|
|
totalEvents() {
|
|
const ret = wasm.eventlog_len(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get current event count (includes all events)
|
|
* @returns {number}
|
|
*/
|
|
len() {
|
|
const ret = wasm.eventlog_len(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create a new event log
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.eventlog_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
EventLogFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get current Merkle root as hex string
|
|
* @returns {string}
|
|
*/
|
|
getRoot() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.eventlog_getRoot(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check if log is empty
|
|
* @returns {boolean}
|
|
*/
|
|
isEmpty() {
|
|
const ret = wasm.eventlog_isEmpty(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) EventLog.prototype[Symbol.dispose] = EventLog.prototype.free;
|
|
|
|
/**
|
|
* Node replication and evolution guidance
|
|
*/
|
|
export class EvolutionEngine {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
EvolutionEngineFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_evolutionengine_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if node should replicate (spawn similar node)
|
|
* @param {string} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
shouldReplicate(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.evolutionengine_shouldReplicate(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Record node performance for fitness evaluation
|
|
* @param {string} node_id
|
|
* @param {number} success_rate
|
|
* @param {number} throughput
|
|
*/
|
|
recordPerformance(node_id, success_rate, throughput) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.evolutionengine_recordPerformance(this.__wbg_ptr, ptr0, len0, success_rate, throughput);
|
|
}
|
|
/**
|
|
* Get network fitness score
|
|
* @returns {number}
|
|
*/
|
|
getNetworkFitness() {
|
|
const ret = wasm.evolutionengine_getNetworkFitness(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get recommended configuration for new nodes
|
|
* @returns {string}
|
|
*/
|
|
getRecommendedConfig() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.evolutionengine_getRecommendedConfig(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
constructor() {
|
|
const ret = wasm.evolutionengine_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
EvolutionEngineFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Evolve patterns for next generation
|
|
*/
|
|
evolve() {
|
|
wasm.evolutionengine_evolve(this.__wbg_ptr);
|
|
}
|
|
}
|
|
if (Symbol.dispose) EvolutionEngine.prototype[Symbol.dispose] = EvolutionEngine.prototype.free;
|
|
|
|
/**
|
|
* Federated model state for tracking learning progress
|
|
*/
|
|
export class FederatedModel {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
FederatedModelFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_federatedmodel_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get parameter dimension
|
|
* @returns {number}
|
|
*/
|
|
getDimension() {
|
|
const ret = wasm.federatedmodel_getDimension(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get parameters as array
|
|
* @returns {Float32Array}
|
|
*/
|
|
getParameters() {
|
|
const ret = wasm.federatedmodel_getParameters(this.__wbg_ptr);
|
|
var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Set parameters from array
|
|
* @param {Float32Array} params
|
|
*/
|
|
setParameters(params) {
|
|
const ptr0 = passArrayF32ToWasm0(params, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.federatedmodel_setParameters(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Apply aggregated gradients to update model
|
|
* @param {Float32Array} gradients
|
|
*/
|
|
applyGradients(gradients) {
|
|
const ptr0 = passArrayF32ToWasm0(gradients, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.federatedmodel_applyGradients(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Set local epochs per round
|
|
* @param {number} epochs
|
|
*/
|
|
setLocalEpochs(epochs) {
|
|
wasm.federatedmodel_setLocalEpochs(this.__wbg_ptr, epochs);
|
|
}
|
|
/**
|
|
* Set learning rate
|
|
* @param {number} lr
|
|
*/
|
|
setLearningRate(lr) {
|
|
wasm.federatedmodel_setLearningRate(this.__wbg_ptr, lr);
|
|
}
|
|
/**
|
|
* Create a new federated model
|
|
* @param {number} dimension
|
|
* @param {number} learning_rate
|
|
* @param {number} momentum
|
|
*/
|
|
constructor(dimension, learning_rate, momentum) {
|
|
const ret = wasm.federatedmodel_new(dimension, learning_rate, momentum);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
FederatedModelFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get current round
|
|
* @returns {bigint}
|
|
*/
|
|
getRound() {
|
|
const ret = wasm.federatedmodel_getRound(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
}
|
|
if (Symbol.dispose) FederatedModel.prototype[Symbol.dispose] = FederatedModel.prototype.free;
|
|
|
|
/**
|
|
* Founding contributor registry
|
|
*/
|
|
export class FoundingRegistry {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
FoundingRegistryFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_foundingregistry_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Process epoch distribution
|
|
* @param {bigint} current_epoch
|
|
* @param {bigint} available_amount
|
|
* @returns {any[]}
|
|
*/
|
|
processEpoch(current_epoch, available_amount) {
|
|
const ret = wasm.foundingregistry_processEpoch(this.__wbg_ptr, current_epoch, available_amount);
|
|
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Calculate vested amount for current epoch
|
|
* @param {bigint} current_epoch
|
|
* @param {bigint} pool_balance
|
|
* @returns {bigint}
|
|
*/
|
|
calculateVested(current_epoch, pool_balance) {
|
|
const ret = wasm.foundingregistry_calculateVested(this.__wbg_ptr, current_epoch, pool_balance);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get founding contributor count
|
|
* @returns {number}
|
|
*/
|
|
getFounderCount() {
|
|
const ret = wasm.foundingregistry_getFounderCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Register additional founding contributor
|
|
* @param {string} id
|
|
* @param {string} category
|
|
* @param {number} weight
|
|
*/
|
|
registerContributor(id, category, weight) {
|
|
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(category, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.foundingregistry_registerContributor(this.__wbg_ptr, ptr0, len0, ptr1, len1, weight);
|
|
}
|
|
constructor() {
|
|
const ret = wasm.foundingregistry_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
FoundingRegistryFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) FoundingRegistry.prototype[Symbol.dispose] = FoundingRegistry.prototype.free;
|
|
|
|
/**
|
|
* Genesis Key - Ultra-compact origin marker (φ-sized: 21 bytes)
|
|
*/
|
|
export class GenesisKey {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
GenesisKeyFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_genesiskey_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get ID as hex
|
|
* @returns {string}
|
|
*/
|
|
getIdHex() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.genesiskey_getIdHex(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Export ultra-compact genesis key (21 bytes only)
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportUltraCompact() {
|
|
const ret = wasm.genesiskey_exportUltraCompact(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Create a new genesis key
|
|
* @param {PiKey} creator
|
|
* @param {number} epoch
|
|
*/
|
|
constructor(creator, epoch) {
|
|
_assertClass(creator, PiKey);
|
|
const ret = wasm.genesiskey_create(creator.__wbg_ptr, epoch);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
GenesisKeyFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get the φ-sized genesis ID
|
|
* @returns {Uint8Array}
|
|
*/
|
|
getId() {
|
|
const ret = wasm.genesiskey_getId(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Verify this genesis key was created by a specific Pi-Key
|
|
* @param {Uint8Array} creator_public_key
|
|
* @returns {boolean}
|
|
*/
|
|
verify(creator_public_key) {
|
|
const ptr0 = passArray8ToWasm0(creator_public_key, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.genesiskey_verify(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get epoch
|
|
* @returns {number}
|
|
*/
|
|
getEpoch() {
|
|
const ret = wasm.genesiskey_getEpoch(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) GenesisKey.prototype[Symbol.dispose] = GenesisKey.prototype.free;
|
|
|
|
/**
|
|
* Genesis node sunset orchestrator
|
|
*/
|
|
export class GenesisSunset {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
GenesisSunsetFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_genesissunset_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if it's safe to retire genesis nodes
|
|
* @returns {boolean}
|
|
*/
|
|
canRetire() {
|
|
const ret = wasm.genesissunset_canRetire(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get sunset status
|
|
* @returns {string}
|
|
*/
|
|
getStatus() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.genesissunset_getStatus(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check if genesis nodes should be read-only
|
|
* @returns {boolean}
|
|
*/
|
|
isReadOnly() {
|
|
const ret = wasm.genesissunset_isReadOnly(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get current sunset phase
|
|
* 0 = Active (genesis required)
|
|
* 1 = Transition (stop new connections)
|
|
* 2 = Read-only (genesis read-only)
|
|
* 3 = Retired (genesis can be removed)
|
|
* @returns {number}
|
|
*/
|
|
getCurrentPhase() {
|
|
const ret = wasm.genesissunset_getCurrentPhase(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Update network node count
|
|
* @param {number} count
|
|
* @returns {number}
|
|
*/
|
|
updateNodeCount(count) {
|
|
const ret = wasm.genesissunset_updateNodeCount(this.__wbg_ptr, count);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if network is self-sustaining
|
|
* @returns {boolean}
|
|
*/
|
|
isSelfSustaining() {
|
|
const ret = wasm.genesissunset_canRetire(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Register a genesis node
|
|
* @param {string} node_id
|
|
*/
|
|
registerGenesisNode(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.genesissunset_registerGenesisNode(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
/**
|
|
* Check if genesis nodes should accept new connections
|
|
* @returns {boolean}
|
|
*/
|
|
shouldAcceptConnections() {
|
|
const ret = wasm.genesissunset_shouldAcceptConnections(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
constructor() {
|
|
const ret = wasm.genesissunset_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
GenesisSunsetFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) GenesisSunset.prototype[Symbol.dispose] = GenesisSunset.prototype.free;
|
|
|
|
/**
|
|
* P2P Gradient Gossip for decentralized federated learning
|
|
*
|
|
* This is the main coordinator for federated learning without a central server.
|
|
*/
|
|
export class GradientGossip {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
GradientGossipFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_gradientgossip_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get number of active peers
|
|
* @returns {number}
|
|
*/
|
|
peerCount() {
|
|
const ret = wasm.gradientgossip_peerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Prune stale peer gradients
|
|
* @returns {number}
|
|
*/
|
|
pruneStale() {
|
|
const ret = wasm.gradientgossip_pruneStale(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Configure differential privacy
|
|
* @param {number} epsilon
|
|
* @param {number} sensitivity
|
|
*/
|
|
configureDifferentialPrivacy(epsilon, sensitivity) {
|
|
wasm.gradientgossip_configureDifferentialPrivacy(this.__wbg_ptr, epsilon, sensitivity);
|
|
}
|
|
/**
|
|
* Advance to next consensus round
|
|
* @returns {bigint}
|
|
*/
|
|
advanceRound() {
|
|
const ret = wasm.gradientgossip_advanceRound(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get gradient dimension
|
|
* @returns {number}
|
|
*/
|
|
getDimension() {
|
|
const ret = wasm.gradientgossip_getDimension(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Enable/disable differential privacy
|
|
* @param {boolean} enabled
|
|
*/
|
|
setDPEnabled(enabled) {
|
|
wasm.gradientgossip_setDPEnabled(this.__wbg_ptr, enabled);
|
|
}
|
|
/**
|
|
* Set model hash for version compatibility
|
|
* @param {Uint8Array} hash
|
|
*/
|
|
setModelHash(hash) {
|
|
const ptr0 = passArray8ToWasm0(hash, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.gradientgossip_setModelHash(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Get current consensus round
|
|
* @returns {bigint}
|
|
*/
|
|
getCurrentRound() {
|
|
const ret = wasm.gradientgossip_getCurrentRound(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Set local gradients from JavaScript
|
|
* @param {Float32Array} gradients
|
|
*/
|
|
setLocalGradients(gradients) {
|
|
const ptr0 = passArrayF32ToWasm0(gradients, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.gradientgossip_setLocalGradients(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Get compression ratio achieved
|
|
* @returns {number}
|
|
*/
|
|
getCompressionRatio() {
|
|
const ret = wasm.gradientgossip_getCompressionRatio(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get aggregated gradients as JavaScript array
|
|
* @returns {Float32Array}
|
|
*/
|
|
getAggregatedGradients() {
|
|
const ret = wasm.gradientgossip_getAggregatedGradients(this.__wbg_ptr);
|
|
var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Create a new GradientGossip instance
|
|
*
|
|
* # Arguments
|
|
* * `local_peer_id` - 32-byte peer identifier
|
|
* * `dimension` - Gradient vector dimension
|
|
* * `k_ratio` - TopK sparsification ratio (0.1 = keep top 10%)
|
|
* @param {Uint8Array} local_peer_id
|
|
* @param {number} dimension
|
|
* @param {number} k_ratio
|
|
*/
|
|
constructor(local_peer_id, dimension, k_ratio) {
|
|
const ptr0 = passArray8ToWasm0(local_peer_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.gradientgossip_new(ptr0, len0, dimension, k_ratio);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
GradientGossipFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.gradientgossip_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) GradientGossip.prototype[Symbol.dispose] = GradientGossip.prototype.free;
|
|
|
|
/**
|
|
* Model consensus manager for federated learning integration
|
|
*/
|
|
export class ModelConsensusManager {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
ModelConsensusManagerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_modelconsensusmanager_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get number of tracked models
|
|
* @returns {number}
|
|
*/
|
|
modelCount() {
|
|
const ret = wasm.modelconsensusmanager_modelCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get number of active disputes
|
|
* @returns {number}
|
|
*/
|
|
disputeCount() {
|
|
const ret = wasm.modelconsensusmanager_disputeCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get number of quarantined updates
|
|
* @returns {number}
|
|
*/
|
|
quarantinedUpdateCount() {
|
|
const ret = wasm.modelconsensusmanager_quarantinedUpdateCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create a new model consensus manager
|
|
* @param {number} min_witnesses
|
|
*/
|
|
constructor(min_witnesses) {
|
|
const ret = wasm.modelconsensusmanager_new(min_witnesses);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
ModelConsensusManagerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.modelconsensusmanager_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) ModelConsensusManager.prototype[Symbol.dispose] = ModelConsensusManager.prototype.free;
|
|
|
|
/**
|
|
* Multi-head attention for distributed task routing
|
|
*/
|
|
export class MultiHeadAttention {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
MultiHeadAttentionFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_multiheadattention_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get embedding dimension
|
|
* @returns {number}
|
|
*/
|
|
dim() {
|
|
const ret = wasm.multiheadattention_dim(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create new multi-head attention
|
|
* @param {number} dim
|
|
* @param {number} num_heads
|
|
*/
|
|
constructor(dim, num_heads) {
|
|
const ret = wasm.multiheadattention_new(dim, num_heads);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
MultiHeadAttentionFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get number of heads
|
|
* @returns {number}
|
|
*/
|
|
numHeads() {
|
|
const ret = wasm.multiheadattention_numHeads(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) MultiHeadAttention.prototype[Symbol.dispose] = MultiHeadAttention.prototype.free;
|
|
|
|
/**
|
|
* Network lifecycle events and Easter eggs manager
|
|
*/
|
|
export class NetworkEvents {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
NetworkEventsFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_networkevents_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get a subtle motivational message
|
|
* @param {bigint} balance
|
|
* @returns {string}
|
|
*/
|
|
getMotivation(balance) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.networkevents_getMotivation(this.__wbg_ptr, balance);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check for discovery triggers (Easter eggs)
|
|
* @param {string} action
|
|
* @param {string} node_id
|
|
* @returns {string | undefined}
|
|
*/
|
|
checkDiscovery(action, node_id) {
|
|
const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.networkevents_checkDiscovery(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
let v3;
|
|
if (ret[0] !== 0) {
|
|
v3 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
}
|
|
return v3;
|
|
}
|
|
/**
|
|
* Get ASCII art for special occasions
|
|
* @returns {string | undefined}
|
|
*/
|
|
getSpecialArt() {
|
|
const ret = wasm.networkevents_getSpecialArt(this.__wbg_ptr);
|
|
let v1;
|
|
if (ret[0] !== 0) {
|
|
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
}
|
|
return v1;
|
|
}
|
|
/**
|
|
* Check milestone achievements
|
|
* @param {bigint} balance
|
|
* @param {string} node_id
|
|
* @returns {string}
|
|
*/
|
|
checkMilestones(balance, node_id) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.networkevents_checkMilestones(this.__wbg_ptr, balance, ptr0, len0);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Set current time (for testing)
|
|
* @param {bigint} timestamp
|
|
*/
|
|
setCurrentTime(timestamp) {
|
|
wasm.networkevents_setCurrentTime(this.__wbg_ptr, timestamp);
|
|
}
|
|
/**
|
|
* Get network status with thematic flair
|
|
* @param {number} node_count
|
|
* @param {bigint} total_ruv
|
|
* @returns {string}
|
|
*/
|
|
getThemedStatus(node_count, total_ruv) {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.networkevents_getThemedStatus(this.__wbg_ptr, node_count, total_ruv);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check for active special events
|
|
* @returns {string}
|
|
*/
|
|
checkActiveEvents() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.networkevents_checkActiveEvents(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get celebration multiplier boost
|
|
* @returns {number}
|
|
*/
|
|
getCelebrationBoost() {
|
|
const ret = wasm.networkevents_getCelebrationBoost(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
constructor() {
|
|
const ret = wasm.networkevents_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
NetworkEventsFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) NetworkEvents.prototype[Symbol.dispose] = NetworkEvents.prototype.free;
|
|
|
|
/**
|
|
* Unified learning intelligence for edge-net nodes
|
|
*/
|
|
export class NetworkLearning {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
NetworkLearningFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_networklearning_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get pattern count
|
|
* @returns {number}
|
|
*/
|
|
patternCount() {
|
|
const ret = wasm.networklearning_patternCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Store a learned pattern
|
|
* @param {string} pattern_json
|
|
* @returns {number}
|
|
*/
|
|
storePattern(pattern_json) {
|
|
const ptr0 = passStringToWasm0(pattern_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.networklearning_storePattern(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Look up similar patterns
|
|
* @param {string} query_json
|
|
* @param {number} k
|
|
* @returns {string}
|
|
*/
|
|
lookupPatterns(query_json, k) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.networklearning_lookupPatterns(this.__wbg_ptr, ptr0, len0, k);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get energy savings ratio for spike-driven attention
|
|
* @param {number} seq_len
|
|
* @param {number} hidden_dim
|
|
* @returns {number}
|
|
*/
|
|
getEnergyRatio(seq_len, hidden_dim) {
|
|
const ret = wasm.networklearning_getEnergyRatio(this.__wbg_ptr, seq_len, hidden_dim);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get trajectory count
|
|
* @returns {number}
|
|
*/
|
|
trajectoryCount() {
|
|
const ret = wasm.networklearning_trajectoryCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Record a task execution trajectory
|
|
* @param {string} trajectory_json
|
|
* @returns {boolean}
|
|
*/
|
|
recordTrajectory(trajectory_json) {
|
|
const ptr0 = passStringToWasm0(trajectory_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.networklearning_recordTrajectory(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Create new network learning intelligence
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.networklearning_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
NetworkLearningFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Prune low-quality patterns
|
|
* @param {number} min_usage
|
|
* @param {number} min_confidence
|
|
* @returns {number}
|
|
*/
|
|
prune(min_usage, min_confidence) {
|
|
const ret = wasm.networklearning_prune(this.__wbg_ptr, min_usage, min_confidence);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get combined statistics
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.networklearning_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) NetworkLearning.prototype[Symbol.dispose] = NetworkLearning.prototype.free;
|
|
|
|
/**
|
|
* Network topology adaptation for self-organization
|
|
*/
|
|
export class NetworkTopology {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
NetworkTopologyFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_networktopology_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Register a node in the topology
|
|
* @param {string} node_id
|
|
* @param {Float32Array} capabilities
|
|
*/
|
|
registerNode(node_id, capabilities) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArrayF32ToWasm0(capabilities, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.networktopology_registerNode(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
}
|
|
/**
|
|
* Get optimal peers for a node
|
|
* @param {string} node_id
|
|
* @param {number} count
|
|
* @returns {string[]}
|
|
*/
|
|
getOptimalPeers(node_id, count) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.networktopology_getOptimalPeers(this.__wbg_ptr, ptr0, len0, count);
|
|
var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Update connection strength between nodes
|
|
* @param {string} from
|
|
* @param {string} to
|
|
* @param {number} success_rate
|
|
*/
|
|
updateConnection(from, to, success_rate) {
|
|
const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(to, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.networktopology_updateConnection(this.__wbg_ptr, ptr0, len0, ptr1, len1, success_rate);
|
|
}
|
|
constructor() {
|
|
const ret = wasm.networktopology_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
NetworkTopologyFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) NetworkTopology.prototype[Symbol.dispose] = NetworkTopology.prototype.free;
|
|
|
|
export class NodeConfig {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
NodeConfigFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_nodeconfig_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Maximum CPU usage when idle (0.0 - 1.0)
|
|
* @returns {number}
|
|
*/
|
|
get cpu_limit() {
|
|
const ret = wasm.__wbg_get_economichealth_velocity(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Maximum CPU usage when idle (0.0 - 1.0)
|
|
* @param {number} arg0
|
|
*/
|
|
set cpu_limit(arg0) {
|
|
wasm.__wbg_set_economichealth_velocity(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Maximum memory usage in bytes
|
|
* @returns {number}
|
|
*/
|
|
get memory_limit() {
|
|
const ret = wasm.__wbg_get_nodeconfig_memory_limit(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Maximum memory usage in bytes
|
|
* @param {number} arg0
|
|
*/
|
|
set memory_limit(arg0) {
|
|
wasm.__wbg_set_nodeconfig_memory_limit(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Maximum bandwidth in bytes/sec
|
|
* @returns {number}
|
|
*/
|
|
get bandwidth_limit() {
|
|
const ret = wasm.__wbg_get_nodeconfig_bandwidth_limit(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Maximum bandwidth in bytes/sec
|
|
* @param {number} arg0
|
|
*/
|
|
set bandwidth_limit(arg0) {
|
|
wasm.__wbg_set_nodeconfig_bandwidth_limit(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Minimum idle time before contributing (ms)
|
|
* @returns {number}
|
|
*/
|
|
get min_idle_time() {
|
|
const ret = wasm.__wbg_get_nodeconfig_min_idle_time(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Minimum idle time before contributing (ms)
|
|
* @param {number} arg0
|
|
*/
|
|
set min_idle_time(arg0) {
|
|
wasm.__wbg_set_nodeconfig_min_idle_time(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Whether to reduce contribution on battery
|
|
* @returns {boolean}
|
|
*/
|
|
get respect_battery() {
|
|
const ret = wasm.__wbg_get_nodeconfig_respect_battery(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Whether to reduce contribution on battery
|
|
* @param {boolean} arg0
|
|
*/
|
|
set respect_battery(arg0) {
|
|
wasm.__wbg_set_nodeconfig_respect_battery(this.__wbg_ptr, arg0);
|
|
}
|
|
}
|
|
if (Symbol.dispose) NodeConfig.prototype[Symbol.dispose] = NodeConfig.prototype.free;
|
|
|
|
export class NodeStats {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(NodeStats.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
NodeStatsFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
NodeStatsFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_nodestats_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Total rUv (Resource Utility Vouchers) earned
|
|
* @returns {bigint}
|
|
*/
|
|
get ruv_earned() {
|
|
const ret = wasm.__wbg_get_nodestats_ruv_earned(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Total rUv (Resource Utility Vouchers) earned
|
|
* @param {bigint} arg0
|
|
*/
|
|
set ruv_earned(arg0) {
|
|
wasm.__wbg_set_nodestats_ruv_earned(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Total rUv spent
|
|
* @returns {bigint}
|
|
*/
|
|
get ruv_spent() {
|
|
const ret = wasm.__wbg_get_nodestats_ruv_spent(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Total rUv spent
|
|
* @param {bigint} arg0
|
|
*/
|
|
set ruv_spent(arg0) {
|
|
wasm.__wbg_set_nodestats_ruv_spent(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Tasks completed
|
|
* @returns {bigint}
|
|
*/
|
|
get tasks_completed() {
|
|
const ret = wasm.__wbg_get_nodestats_tasks_completed(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Tasks completed
|
|
* @param {bigint} arg0
|
|
*/
|
|
set tasks_completed(arg0) {
|
|
wasm.__wbg_set_nodestats_tasks_completed(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Tasks submitted
|
|
* @returns {bigint}
|
|
*/
|
|
get tasks_submitted() {
|
|
const ret = wasm.__wbg_get_nodestats_tasks_submitted(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Tasks submitted
|
|
* @param {bigint} arg0
|
|
*/
|
|
set tasks_submitted(arg0) {
|
|
wasm.__wbg_set_nodestats_tasks_submitted(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Total uptime in seconds
|
|
* @returns {bigint}
|
|
*/
|
|
get uptime_seconds() {
|
|
const ret = wasm.__wbg_get_nodestats_uptime_seconds(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Total uptime in seconds
|
|
* @param {bigint} arg0
|
|
*/
|
|
set uptime_seconds(arg0) {
|
|
wasm.__wbg_set_nodestats_uptime_seconds(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Current reputation score (0.0 - 1.0)
|
|
* @returns {number}
|
|
*/
|
|
get reputation() {
|
|
const ret = wasm.__wbg_get_nodestats_reputation(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Current reputation score (0.0 - 1.0)
|
|
* @param {number} arg0
|
|
*/
|
|
set reputation(arg0) {
|
|
wasm.__wbg_set_nodestats_reputation(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Current contribution multiplier
|
|
* @returns {number}
|
|
*/
|
|
get multiplier() {
|
|
const ret = wasm.__wbg_get_nodestats_multiplier(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Current contribution multiplier
|
|
* @param {number} arg0
|
|
*/
|
|
set multiplier(arg0) {
|
|
wasm.__wbg_set_nodestats_multiplier(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* Active lifecycle events
|
|
* @returns {number}
|
|
*/
|
|
get celebration_boost() {
|
|
const ret = wasm.__wbg_get_nodestats_celebration_boost(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Active lifecycle events
|
|
* @param {number} arg0
|
|
*/
|
|
set celebration_boost(arg0) {
|
|
wasm.__wbg_set_nodestats_celebration_boost(this.__wbg_ptr, arg0);
|
|
}
|
|
}
|
|
if (Symbol.dispose) NodeStats.prototype[Symbol.dispose] = NodeStats.prototype.free;
|
|
|
|
/**
|
|
* Network optimization for resource efficiency
|
|
*/
|
|
export class OptimizationEngine {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
OptimizationEngineFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_optimizationengine_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Record task routing outcome
|
|
* @param {string} task_type
|
|
* @param {string} node_id
|
|
* @param {bigint} latency_ms
|
|
* @param {boolean} success
|
|
*/
|
|
recordRouting(task_type, node_id, latency_ms, success) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.optimizationengine_recordRouting(this.__wbg_ptr, ptr0, len0, ptr1, len1, latency_ms, success);
|
|
}
|
|
/**
|
|
* Get optimal node for a task type
|
|
* @param {string} task_type
|
|
* @param {string[]} candidates
|
|
* @returns {string}
|
|
*/
|
|
selectOptimalNode(task_type, candidates) {
|
|
let deferred3_0;
|
|
let deferred3_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArrayJsValueToWasm0(candidates, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.optimizationengine_selectOptimalNode(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
deferred3_0 = ret[0];
|
|
deferred3_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
}
|
|
}
|
|
constructor() {
|
|
const ret = wasm.optimizationengine_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
OptimizationEngineFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get optimization stats
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.optimizationengine_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) OptimizationEngine.prototype[Symbol.dispose] = OptimizationEngine.prototype.free;
|
|
|
|
/**
|
|
* Ultra-compact Pi-Key (40 bytes identity + 21 bytes genesis signature)
|
|
*/
|
|
export class PiKey {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(PiKey.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
PiKeyFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
PiKeyFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_pikey_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get the Pi-sized identity (40 bytes)
|
|
* @returns {Uint8Array}
|
|
*/
|
|
getIdentity() {
|
|
const ret = wasm.pikey_getIdentity(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Get short identity (first 8 bytes as hex)
|
|
* @returns {string}
|
|
*/
|
|
getShortId() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.pikey_getShortId(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Export minimal key representation (Pi + Phi sized = 61 bytes total)
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportCompact() {
|
|
const ret = wasm.pikey_exportCompact(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Get public key for verification
|
|
* @returns {Uint8Array}
|
|
*/
|
|
getPublicKey() {
|
|
const ret = wasm.pikey_getPublicKey(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Verify this key has Pi magic marker
|
|
* @returns {boolean}
|
|
*/
|
|
verifyPiMagic() {
|
|
const ret = wasm.pikey_verifyPiMagic(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get identity as hex string
|
|
* @returns {string}
|
|
*/
|
|
getIdentityHex() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.pikey_getIdentityHex(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Restore from encrypted backup (supports both v1 legacy and v2 Argon2id)
|
|
* @param {Uint8Array} backup
|
|
* @param {string} password
|
|
* @returns {PiKey}
|
|
*/
|
|
static restoreFromBackup(backup, password) {
|
|
const ptr0 = passArray8ToWasm0(backup, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.pikey_restoreFromBackup(ptr0, len0, ptr1, len1);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return PiKey.__wrap(ret[0]);
|
|
}
|
|
/**
|
|
* Create encrypted backup of private key using Argon2id KDF
|
|
* @param {string} password
|
|
* @returns {Uint8Array}
|
|
*/
|
|
createEncryptedBackup(password) {
|
|
const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.pikey_createEncryptedBackup(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Get the Phi-sized genesis fingerprint (21 bytes)
|
|
* @returns {Uint8Array}
|
|
*/
|
|
getGenesisFingerprint() {
|
|
const ret = wasm.pikey_getGenesisFingerprint(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Sign data with this key
|
|
* @param {Uint8Array} data
|
|
* @returns {Uint8Array}
|
|
*/
|
|
sign(data) {
|
|
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.pikey_sign(this.__wbg_ptr, ptr0, len0);
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Verify signature from another Pi-Key
|
|
* @param {Uint8Array} data
|
|
* @param {Uint8Array} signature
|
|
* @param {Uint8Array} public_key
|
|
* @returns {boolean}
|
|
*/
|
|
verify(data, signature, public_key) {
|
|
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
const ret = wasm.pikey_verify(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Generate a new Pi-Key with genesis linking
|
|
* @param {Uint8Array | null} [genesis_seed]
|
|
*/
|
|
constructor(genesis_seed) {
|
|
var ptr0 = isLikeNone(genesis_seed) ? 0 : passArray8ToWasm0(genesis_seed, wasm.__wbindgen_malloc);
|
|
var len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.pikey_generate(ptr0, len0);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
PiKeyFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get key statistics
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.pikey_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) PiKey.prototype[Symbol.dispose] = PiKey.prototype.free;
|
|
|
|
/**
|
|
* QDAG Ledger - the full transaction graph
|
|
*/
|
|
export class QDAGLedger {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
QDAGLedgerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_qdagledger_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Export ledger state for sync
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportState() {
|
|
const ret = wasm.qdagledger_exportState(this.__wbg_ptr);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Import ledger state from sync
|
|
* @param {Uint8Array} state_bytes
|
|
* @returns {number}
|
|
*/
|
|
importState(state_bytes) {
|
|
const ptr0 = passArray8ToWasm0(state_bytes, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.qdagledger_importState(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return ret[0] >>> 0;
|
|
}
|
|
/**
|
|
* Get total supply
|
|
* @returns {bigint}
|
|
*/
|
|
totalSupply() {
|
|
const ret = wasm.qdagledger_totalSupply(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get staked amount for a node
|
|
* @param {string} node_id
|
|
* @returns {bigint}
|
|
*/
|
|
stakedAmount(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.qdagledger_stakedAmount(this.__wbg_ptr, ptr0, len0);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Create genesis transaction (called once at network start)
|
|
* @param {bigint} initial_supply
|
|
* @param {Uint8Array} founder_pubkey
|
|
* @returns {Uint8Array}
|
|
*/
|
|
createGenesis(initial_supply, founder_pubkey) {
|
|
const ptr0 = passArray8ToWasm0(founder_pubkey, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.qdagledger_createGenesis(this.__wbg_ptr, initial_supply, ptr0, len0);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Get transaction count
|
|
* @returns {number}
|
|
*/
|
|
transactionCount() {
|
|
const ret = wasm.qdagledger_transactionCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create and validate a new transaction
|
|
* @param {string} sender_id
|
|
* @param {string} recipient_id
|
|
* @param {bigint} amount
|
|
* @param {number} tx_type
|
|
* @param {Uint8Array} sender_privkey
|
|
* @param {Uint8Array} sender_pubkey
|
|
* @returns {Uint8Array}
|
|
*/
|
|
createTransaction(sender_id, recipient_id, amount, tx_type, sender_privkey, sender_pubkey) {
|
|
const ptr0 = passStringToWasm0(sender_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(recipient_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passArray8ToWasm0(sender_privkey, wasm.__wbindgen_malloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
const ptr3 = passArray8ToWasm0(sender_pubkey, wasm.__wbindgen_malloc);
|
|
const len3 = WASM_VECTOR_LEN;
|
|
const ret = wasm.qdagledger_createTransaction(this.__wbg_ptr, ptr0, len0, ptr1, len1, amount, tx_type, ptr2, len2, ptr3, len3);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v5;
|
|
}
|
|
/**
|
|
* Create a new QDAG ledger
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.qdagledger_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
QDAGLedgerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get balance for a node
|
|
* @param {string} node_id
|
|
* @returns {bigint}
|
|
*/
|
|
balance(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.qdagledger_balance(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get tip count
|
|
* @returns {number}
|
|
*/
|
|
tipCount() {
|
|
const ret = wasm.qdagledger_tipCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) QDAGLedger.prototype[Symbol.dispose] = QDAGLedger.prototype.free;
|
|
|
|
/**
|
|
* Manages quarantine status of contested claims
|
|
*/
|
|
export class QuarantineManager {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
QuarantineManagerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_quarantinemanager_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get number of quarantined claims
|
|
* @returns {number}
|
|
*/
|
|
quarantinedCount() {
|
|
const ret = wasm.quarantinemanager_quarantinedCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create a new quarantine manager
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.quarantinemanager_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
QuarantineManagerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Check if claim can be used in decisions
|
|
* @param {string} claim_id
|
|
* @returns {boolean}
|
|
*/
|
|
canUse(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.quarantinemanager_canUse(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Check quarantine level for a claim
|
|
* @param {string} claim_id
|
|
* @returns {number}
|
|
*/
|
|
getLevel(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.quarantinemanager_getLevel(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Set quarantine level
|
|
* @param {string} claim_id
|
|
* @param {number} level
|
|
*/
|
|
setLevel(claim_id, level) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.quarantinemanager_setLevel(this.__wbg_ptr, ptr0, len0, level);
|
|
}
|
|
}
|
|
if (Symbol.dispose) QuarantineManager.prototype[Symbol.dispose] = QuarantineManager.prototype.free;
|
|
|
|
/**
|
|
* RAC-specific combined economic engine managing stakes, reputation, and rewards
|
|
*/
|
|
export class RacEconomicEngine {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
RacEconomicEngineFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_raceconomicengine_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get summary statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getSummary() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.raceconomicengine_getSummary(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check if node can participate (has stake + reputation)
|
|
* @param {Uint8Array} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
canParticipate(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.raceconomicengine_canParticipate(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get combined score (stake-weighted reputation)
|
|
* @param {Uint8Array} node_id
|
|
* @returns {number}
|
|
*/
|
|
getCombinedScore(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.raceconomicengine_getCombinedScore(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Create a new RAC economic engine
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.raceconomicengine_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
RacEconomicEngineFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) RacEconomicEngine.prototype[Symbol.dispose] = RacEconomicEngine.prototype.free;
|
|
|
|
/**
|
|
* RAC-specific semantic gossip router for event propagation
|
|
*/
|
|
export class RacSemanticRouter {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
RacSemanticRouterFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_racsemanticrouter_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get peer count
|
|
* @returns {number}
|
|
*/
|
|
peerCount() {
|
|
const ret = wasm.racsemanticrouter_peerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create a new semantic router
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.racsemanticrouter_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
RacSemanticRouterFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) RacSemanticRouter.prototype[Symbol.dispose] = RacSemanticRouter.prototype.free;
|
|
|
|
/**
|
|
* Rate limiter to prevent spam/DoS
|
|
*/
|
|
export class RateLimiter {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
RateLimiterFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_ratelimiter_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if request is allowed
|
|
* @param {string} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
checkAllowed(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.ratelimiter_checkAllowed(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {bigint} window_ms
|
|
* @param {number} max_requests
|
|
*/
|
|
constructor(window_ms, max_requests) {
|
|
const ret = wasm.ratelimiter_new(window_ms, max_requests);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
RateLimiterFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Reset rate limiter
|
|
*/
|
|
reset() {
|
|
wasm.ratelimiter_reset(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Get current count for a node
|
|
* @param {string} node_id
|
|
* @returns {number}
|
|
*/
|
|
getCount(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.ratelimiter_getCount(this.__wbg_ptr, ptr0, len0);
|
|
return ret >>> 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) RateLimiter.prototype[Symbol.dispose] = RateLimiter.prototype.free;
|
|
|
|
/**
|
|
* ReasoningBank for storing and retrieving learned patterns
|
|
* Optimized with spatial indexing for O(1) approximate lookups
|
|
*/
|
|
export class ReasoningBank {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
ReasoningBankFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_reasoningbank_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create a new ReasoningBank
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.reasoningbank_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
ReasoningBankFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get total pattern count
|
|
* @returns {number}
|
|
*/
|
|
count() {
|
|
const ret = wasm.reasoningbank_count(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Prune low-quality patterns
|
|
* @param {number} min_usage
|
|
* @param {number} min_confidence
|
|
* @returns {number}
|
|
*/
|
|
prune(min_usage, min_confidence) {
|
|
const ret = wasm.reasoningbank_prune(this.__wbg_ptr, min_usage, min_confidence);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Store a new pattern (JSON format)
|
|
* @param {string} pattern_json
|
|
* @returns {number}
|
|
*/
|
|
store(pattern_json) {
|
|
const ptr0 = passStringToWasm0(pattern_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.reasoningbank_store(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Lookup most similar patterns (OPTIMIZED with spatial indexing)
|
|
* @param {string} query_json
|
|
* @param {number} k
|
|
* @returns {string}
|
|
*/
|
|
lookup(query_json, k) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.reasoningbank_lookup(this.__wbg_ptr, ptr0, len0, k);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get bank statistics
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.reasoningbank_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) ReasoningBank.prototype[Symbol.dispose] = ReasoningBank.prototype.free;
|
|
|
|
/**
|
|
* Reputation manager with decay mechanics
|
|
*/
|
|
export class ReputationManager {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
ReputationManagerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_reputationmanager_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get number of tracked nodes
|
|
* @returns {number}
|
|
*/
|
|
nodeCount() {
|
|
const ret = wasm.reputationmanager_nodeCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get effective reputation for a node (with decay applied)
|
|
* @param {Uint8Array} node_id
|
|
* @returns {number}
|
|
*/
|
|
getReputation(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.reputationmanager_getReputation(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get average network reputation
|
|
* @returns {number}
|
|
*/
|
|
averageReputation() {
|
|
const ret = wasm.reputationmanager_averageReputation(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if node has sufficient reputation
|
|
* @param {Uint8Array} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
hasSufficientReputation(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.reputationmanager_hasSufficientReputation(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Create a new reputation manager
|
|
* @param {number} decay_rate
|
|
* @param {bigint} decay_interval_ms
|
|
*/
|
|
constructor(decay_rate, decay_interval_ms) {
|
|
const ret = wasm.reputationmanager_new(decay_rate, decay_interval_ms);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
ReputationManagerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) ReputationManager.prototype[Symbol.dispose] = ReputationManager.prototype.free;
|
|
|
|
/**
|
|
* Reputation system for nodes
|
|
*/
|
|
export class ReputationSystem {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
ReputationSystemFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_reputationsystem_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get reputation score for a node
|
|
* @param {string} node_id
|
|
* @returns {number}
|
|
*/
|
|
getReputation(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.reputationsystem_getReputation(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Record failed task completion
|
|
* @param {string} node_id
|
|
*/
|
|
recordFailure(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.reputationsystem_recordFailure(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
/**
|
|
* Record penalty (fraud, invalid result)
|
|
* @param {string} node_id
|
|
* @param {number} severity
|
|
*/
|
|
recordPenalty(node_id, severity) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.reputationsystem_recordPenalty(this.__wbg_ptr, ptr0, len0, severity);
|
|
}
|
|
/**
|
|
* Record successful task completion
|
|
* @param {string} node_id
|
|
*/
|
|
recordSuccess(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.reputationsystem_recordSuccess(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
/**
|
|
* Check if node can participate
|
|
* @param {string} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
canParticipate(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.reputationsystem_canParticipate(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
constructor() {
|
|
const ret = wasm.reputationsystem_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
ReputationSystemFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) ReputationSystem.prototype[Symbol.dispose] = ReputationSystem.prototype.free;
|
|
|
|
export class RewardDistribution {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(RewardDistribution.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
RewardDistributionFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
RewardDistributionFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_rewarddistribution_free(ptr, 0);
|
|
}
|
|
/**
|
|
* @returns {bigint}
|
|
*/
|
|
get total() {
|
|
const ret = wasm.__wbg_get_nodestats_ruv_earned(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* @param {bigint} arg0
|
|
*/
|
|
set total(arg0) {
|
|
wasm.__wbg_set_nodestats_ruv_earned(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* @returns {bigint}
|
|
*/
|
|
get contributor_share() {
|
|
const ret = wasm.__wbg_get_nodestats_ruv_spent(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* @param {bigint} arg0
|
|
*/
|
|
set contributor_share(arg0) {
|
|
wasm.__wbg_set_nodestats_ruv_spent(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* @returns {bigint}
|
|
*/
|
|
get treasury_share() {
|
|
const ret = wasm.__wbg_get_nodestats_tasks_completed(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* @param {bigint} arg0
|
|
*/
|
|
set treasury_share(arg0) {
|
|
wasm.__wbg_set_nodestats_tasks_completed(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* @returns {bigint}
|
|
*/
|
|
get protocol_share() {
|
|
const ret = wasm.__wbg_get_nodestats_tasks_submitted(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* @param {bigint} arg0
|
|
*/
|
|
set protocol_share(arg0) {
|
|
wasm.__wbg_set_nodestats_tasks_submitted(this.__wbg_ptr, arg0);
|
|
}
|
|
/**
|
|
* @returns {bigint}
|
|
*/
|
|
get founder_share() {
|
|
const ret = wasm.__wbg_get_nodestats_uptime_seconds(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* @param {bigint} arg0
|
|
*/
|
|
set founder_share(arg0) {
|
|
wasm.__wbg_set_nodestats_uptime_seconds(this.__wbg_ptr, arg0);
|
|
}
|
|
}
|
|
if (Symbol.dispose) RewardDistribution.prototype[Symbol.dispose] = RewardDistribution.prototype.free;
|
|
|
|
/**
|
|
* Manages time-locked rewards
|
|
*/
|
|
export class RewardManager {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
RewardManagerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_rewardmanager_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get number of pending rewards
|
|
* @returns {number}
|
|
*/
|
|
pendingCount() {
|
|
const ret = wasm.rewardmanager_pendingCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get total pending reward amount
|
|
* @returns {bigint}
|
|
*/
|
|
pendingAmount() {
|
|
const ret = wasm.rewardmanager_pendingAmount(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get claimable rewards for a node
|
|
* @param {Uint8Array} node_id
|
|
* @returns {bigint}
|
|
*/
|
|
claimableAmount(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.rewardmanager_claimableAmount(this.__wbg_ptr, ptr0, len0);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Create a new reward manager
|
|
* @param {bigint} default_vesting_ms
|
|
*/
|
|
constructor(default_vesting_ms) {
|
|
const ret = wasm.rewardmanager_new(default_vesting_ms);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
RewardManagerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) RewardManager.prototype[Symbol.dispose] = RewardManager.prototype.free;
|
|
|
|
/**
|
|
* Semantic router for intelligent gossip and peer discovery
|
|
*/
|
|
export class SemanticRouter {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(SemanticRouter.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
SemanticRouterFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
SemanticRouterFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_semanticrouter_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get peer count
|
|
* @returns {number}
|
|
*/
|
|
peerCount() {
|
|
const ret = wasm.semanticrouter_peerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get topic count
|
|
* @returns {number}
|
|
*/
|
|
topicCount() {
|
|
const ret = wasm.semanticrouter_topicCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create with custom parameters
|
|
* @param {number} embedding_dim
|
|
* @param {number} semantic_neighbors
|
|
* @param {number} random_sample
|
|
* @returns {SemanticRouter}
|
|
*/
|
|
static withParams(embedding_dim, semantic_neighbors, random_sample) {
|
|
const ret = wasm.semanticrouter_withParams(embedding_dim, semantic_neighbors, random_sample);
|
|
return SemanticRouter.__wrap(ret);
|
|
}
|
|
/**
|
|
* Set my peer identity
|
|
* @param {Uint8Array} peer_id
|
|
*/
|
|
setMyPeerId(peer_id) {
|
|
const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.semanticrouter_setMyPeerId(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
/**
|
|
* Get active peer count (seen in last 60 seconds)
|
|
* @returns {number}
|
|
*/
|
|
activePeerCount() {
|
|
const ret = wasm.semanticrouter_activePeerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Set my capabilities and update my centroid
|
|
* @param {string[]} capabilities
|
|
*/
|
|
setMyCapabilities(capabilities) {
|
|
const ptr0 = passArrayJsValueToWasm0(capabilities, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.semanticrouter_setMyCapabilities(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
/**
|
|
* Create a new semantic router
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.semanticrouter_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
SemanticRouterFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.semanticrouter_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) SemanticRouter.prototype[Symbol.dispose] = SemanticRouter.prototype.free;
|
|
|
|
/**
|
|
* Session Key - Euler-sized ephemeral key (e-sized: 34 bytes)
|
|
*/
|
|
export class SessionKey {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
SessionKeyFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_sessionkey_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get ID as hex
|
|
* @returns {string}
|
|
*/
|
|
getIdHex() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.sessionkey_getIdHex(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Check if session is expired
|
|
* @returns {boolean}
|
|
*/
|
|
isExpired() {
|
|
const ret = wasm.sessionkey_isExpired(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get parent identity fingerprint
|
|
* @returns {Uint8Array}
|
|
*/
|
|
getParentIdentity() {
|
|
const ret = wasm.sessionkey_getParentIdentity(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Create a new session key linked to a Pi-Key identity
|
|
* @param {PiKey} parent
|
|
* @param {number} ttl_seconds
|
|
*/
|
|
constructor(parent, ttl_seconds) {
|
|
_assertClass(parent, PiKey);
|
|
const ret = wasm.sessionkey_create(parent.__wbg_ptr, ttl_seconds);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
SessionKeyFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get the e-sized session ID
|
|
* @returns {Uint8Array}
|
|
*/
|
|
getId() {
|
|
const ret = wasm.sessionkey_getId(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Decrypt data with this session key
|
|
* @param {Uint8Array} data
|
|
* @returns {Uint8Array}
|
|
*/
|
|
decrypt(data) {
|
|
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.sessionkey_decrypt(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Encrypt data with this session key
|
|
* @param {Uint8Array} plaintext
|
|
* @returns {Uint8Array}
|
|
*/
|
|
encrypt(plaintext) {
|
|
const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.sessionkey_encrypt(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
}
|
|
if (Symbol.dispose) SessionKey.prototype[Symbol.dispose] = SessionKey.prototype.free;
|
|
|
|
/**
|
|
* Spike-driven attention for energy-efficient compute (87x savings)
|
|
*/
|
|
export class SpikeDrivenAttention {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(SpikeDrivenAttention.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
SpikeDrivenAttentionFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
SpikeDrivenAttentionFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_spikedrivenattention_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create with custom parameters
|
|
* @param {number} threshold
|
|
* @param {number} steps
|
|
* @param {number} refractory
|
|
* @returns {SpikeDrivenAttention}
|
|
*/
|
|
static withConfig(threshold, steps, refractory) {
|
|
const ret = wasm.spikedrivenattention_withConfig(threshold, steps, refractory);
|
|
return SpikeDrivenAttention.__wrap(ret);
|
|
}
|
|
/**
|
|
* Estimate energy savings ratio compared to standard attention
|
|
* @param {number} seq_len
|
|
* @param {number} hidden_dim
|
|
* @returns {number}
|
|
*/
|
|
energyRatio(seq_len, hidden_dim) {
|
|
const ret = wasm.spikedrivenattention_energyRatio(this.__wbg_ptr, seq_len, hidden_dim);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Create new spike-driven attention with default config
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.spikedrivenattention_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
SpikeDrivenAttentionFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) SpikeDrivenAttention.prototype[Symbol.dispose] = SpikeDrivenAttention.prototype.free;
|
|
|
|
/**
|
|
* Spot-check system for result verification
|
|
*/
|
|
export class SpotChecker {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
SpotCheckerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_spotchecker_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Check if a task should include a spot-check
|
|
* @returns {boolean}
|
|
*/
|
|
shouldCheck() {
|
|
const ret = wasm.spotchecker_shouldCheck(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Add a known challenge-response pair
|
|
* @param {string} task_type
|
|
* @param {Uint8Array} input
|
|
* @param {Uint8Array} expected_output
|
|
*/
|
|
addChallenge(task_type, input, expected_output) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passArray8ToWasm0(expected_output, wasm.__wbindgen_malloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
wasm.spotchecker_addChallenge(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
}
|
|
/**
|
|
* Get a random challenge for a task type
|
|
* @param {string} task_type
|
|
* @returns {Uint8Array | undefined}
|
|
*/
|
|
getChallenge(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.spotchecker_getChallenge(this.__wbg_ptr, ptr0, len0);
|
|
let v2;
|
|
if (ret[0] !== 0) {
|
|
v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
}
|
|
return v2;
|
|
}
|
|
/**
|
|
* Verify a challenge response
|
|
* @param {Uint8Array} input_hash
|
|
* @param {Uint8Array} output
|
|
* @returns {boolean}
|
|
*/
|
|
verifyResponse(input_hash, output) {
|
|
const ptr0 = passArray8ToWasm0(input_hash, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(output, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.spotchecker_verifyResponse(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {number} check_probability
|
|
*/
|
|
constructor(check_probability) {
|
|
const ret = wasm.spotchecker_new(check_probability);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
SpotCheckerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) SpotChecker.prototype[Symbol.dispose] = SpotChecker.prototype.free;
|
|
|
|
/**
|
|
* Stake manager for the network
|
|
*/
|
|
export class StakeManager {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
StakeManagerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_stakemanager_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get number of stakers
|
|
* @returns {number}
|
|
*/
|
|
stakerCount() {
|
|
const ret = wasm.stakemanager_stakerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get total staked amount in network
|
|
* @returns {bigint}
|
|
*/
|
|
totalStaked() {
|
|
const ret = wasm.stakemanager_totalStaked(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get minimum stake requirement
|
|
* @returns {bigint}
|
|
*/
|
|
getMinStake() {
|
|
const ret = wasm.stakemanager_getMinStake(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Check if node has sufficient stake
|
|
* @param {Uint8Array} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
hasSufficientStake(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.stakemanager_hasSufficientStake(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Create a new stake manager
|
|
* @param {bigint} min_stake
|
|
*/
|
|
constructor(min_stake) {
|
|
const ret = wasm.stakemanager_new(min_stake);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
StakeManagerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get staked amount for a node
|
|
* @param {Uint8Array} node_id
|
|
* @returns {bigint}
|
|
*/
|
|
getStake(node_id) {
|
|
const ptr0 = passArray8ToWasm0(node_id, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.stakemanager_getStake(this.__wbg_ptr, ptr0, len0);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
}
|
|
if (Symbol.dispose) StakeManager.prototype[Symbol.dispose] = StakeManager.prototype.free;
|
|
|
|
/**
|
|
* Unified swarm intelligence coordinator
|
|
*/
|
|
export class SwarmIntelligence {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
SwarmIntelligenceFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_swarmintelligence_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get queue size
|
|
* @returns {number}
|
|
*/
|
|
queueSize() {
|
|
const ret = wasm.swarmintelligence_queueSize(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Set belief for a topic's decision
|
|
* @param {string} topic
|
|
* @param {bigint} decision_id
|
|
* @param {number} probability
|
|
*/
|
|
setBelief(topic, decision_id, probability) {
|
|
const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.swarmintelligence_setBelief(this.__wbg_ptr, ptr0, len0, decision_id, probability);
|
|
}
|
|
/**
|
|
* Add pattern to collective memory
|
|
* @param {string} pattern_json
|
|
* @returns {boolean}
|
|
*/
|
|
addPattern(pattern_json) {
|
|
const ptr0 = passStringToWasm0(pattern_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.swarmintelligence_addPattern(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Run memory consolidation
|
|
* @returns {number}
|
|
*/
|
|
consolidate() {
|
|
const ret = wasm.swarmintelligence_consolidate(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Check if topic has reached consensus
|
|
* @param {string} topic
|
|
* @returns {boolean}
|
|
*/
|
|
hasConsensus(topic) {
|
|
const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.swarmintelligence_hasConsensus(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get collective memory pattern count
|
|
* @returns {number}
|
|
*/
|
|
patternCount() {
|
|
const ret = wasm.swarmintelligence_patternCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Search collective memory
|
|
* @param {string} query_json
|
|
* @param {number} k
|
|
* @returns {string}
|
|
*/
|
|
searchPatterns(query_json, k) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.swarmintelligence_searchPatterns(this.__wbg_ptr, ptr0, len0, k);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Start a new consensus round for a topic
|
|
* @param {string} topic
|
|
* @param {number} threshold
|
|
*/
|
|
startConsensus(topic, threshold) {
|
|
const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.swarmintelligence_startConsensus(this.__wbg_ptr, ptr0, len0, threshold);
|
|
}
|
|
/**
|
|
* Negotiate beliefs for a topic
|
|
* @param {string} topic
|
|
* @param {string} beliefs_json
|
|
* @returns {boolean}
|
|
*/
|
|
negotiateBeliefs(topic, beliefs_json) {
|
|
const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(beliefs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.swarmintelligence_negotiateBeliefs(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get consensus decision for topic
|
|
* @param {string} topic
|
|
* @returns {bigint | undefined}
|
|
*/
|
|
getConsensusDecision(topic) {
|
|
const ptr0 = passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.swarmintelligence_getConsensusDecision(this.__wbg_ptr, ptr0, len0);
|
|
return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
|
|
}
|
|
/**
|
|
* Create new swarm intelligence coordinator
|
|
* @param {string} node_id
|
|
*/
|
|
constructor(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.swarmintelligence_new(ptr0, len0);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
SwarmIntelligenceFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Run hippocampal replay
|
|
* @returns {number}
|
|
*/
|
|
replay() {
|
|
const ret = wasm.swarmintelligence_replay(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get node ID
|
|
* @returns {string}
|
|
*/
|
|
nodeId() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.swarmintelligence_nodeId(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get combined statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.swarmintelligence_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) SwarmIntelligence.prototype[Symbol.dispose] = SwarmIntelligence.prototype.free;
|
|
|
|
/**
|
|
* Sybil resistance mechanisms
|
|
*/
|
|
export class SybilDefense {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
SybilDefenseFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_sybildefense_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Register a node with its fingerprint
|
|
* @param {string} node_id
|
|
* @param {string} fingerprint
|
|
* @returns {boolean}
|
|
*/
|
|
registerNode(node_id, fingerprint) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(fingerprint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.sybildefense_registerNode(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get sybil score (0.0 = likely unique, 1.0 = likely sybil)
|
|
* @param {string} node_id
|
|
* @returns {number}
|
|
*/
|
|
getSybilScore(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.sybildefense_getSybilScore(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if node is likely a sybil
|
|
* @param {string} node_id
|
|
* @returns {boolean}
|
|
*/
|
|
isSuspectedSybil(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.sybildefense_isSuspectedSybil(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
constructor() {
|
|
const ret = wasm.sybildefense_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
SybilDefenseFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) SybilDefense.prototype[Symbol.dispose] = SybilDefense.prototype.free;
|
|
|
|
/**
|
|
* Task priority levels
|
|
* @enum {0 | 1 | 2}
|
|
*/
|
|
export const TaskPriority = Object.freeze({
|
|
Low: 0, "0": "Low",
|
|
Normal: 1, "1": "Normal",
|
|
High: 2, "2": "High",
|
|
});
|
|
|
|
/**
|
|
* Task types supported by the network
|
|
* @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
|
|
*/
|
|
export const TaskType = Object.freeze({
|
|
/**
|
|
* Vector search in HNSW index
|
|
*/
|
|
VectorSearch: 0, "0": "VectorSearch",
|
|
/**
|
|
* Vector insertion
|
|
*/
|
|
VectorInsert: 1, "1": "VectorInsert",
|
|
/**
|
|
* Generate embeddings
|
|
*/
|
|
Embedding: 2, "2": "Embedding",
|
|
/**
|
|
* Semantic task-to-agent matching
|
|
*/
|
|
SemanticMatch: 3, "3": "SemanticMatch",
|
|
/**
|
|
* Neural network inference
|
|
*/
|
|
NeuralInference: 4, "4": "NeuralInference",
|
|
/**
|
|
* AES encryption/decryption
|
|
*/
|
|
Encryption: 5, "5": "Encryption",
|
|
/**
|
|
* Data compression
|
|
*/
|
|
Compression: 6, "6": "Compression",
|
|
/**
|
|
* Custom WASM module (requires verification)
|
|
*/
|
|
CustomWasm: 7, "7": "CustomWasm",
|
|
});
|
|
|
|
/**
|
|
* TopK gradient sparsifier with error feedback for accuracy preservation
|
|
*
|
|
* Error feedback accumulates residuals from previous rounds to prevent
|
|
* information loss from aggressive compression.
|
|
*/
|
|
export class TopKSparsifier {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
TopKSparsifierFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_topksparsifier_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Reset error feedback buffer
|
|
*/
|
|
resetErrorFeedback() {
|
|
wasm.topksparsifier_resetErrorFeedback(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Get compression ratio
|
|
* @returns {number}
|
|
*/
|
|
getCompressionRatio() {
|
|
const ret = wasm.topksparsifier_getCompressionRatio(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get error feedback buffer size
|
|
* @returns {number}
|
|
*/
|
|
getErrorBufferSize() {
|
|
const ret = wasm.topksparsifier_getErrorBufferSize(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create a new TopK sparsifier
|
|
*
|
|
* # Arguments
|
|
* * `k_ratio` - Fraction of gradients to keep (0.1 = top 10%)
|
|
* @param {number} k_ratio
|
|
*/
|
|
constructor(k_ratio) {
|
|
const ret = wasm.topksparsifier_new(k_ratio);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
TopKSparsifierFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) TopKSparsifier.prototype[Symbol.dispose] = TopKSparsifier.prototype.free;
|
|
|
|
/**
|
|
* Ring buffer tracker for task trajectories
|
|
*/
|
|
export class TrajectoryTracker {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
TrajectoryTrackerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_trajectorytracker_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create a new trajectory tracker
|
|
* @param {number} max_size
|
|
*/
|
|
constructor(max_size) {
|
|
const ret = wasm.trajectorytracker_new(max_size);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
TrajectoryTrackerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Get count of trajectories
|
|
* @returns {number}
|
|
*/
|
|
count() {
|
|
const ret = wasm.trajectorytracker_count(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Record a new trajectory
|
|
* @param {string} trajectory_json
|
|
* @returns {boolean}
|
|
*/
|
|
record(trajectory_json) {
|
|
const ptr0 = passStringToWasm0(trajectory_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.trajectorytracker_record(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.trajectorytracker_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) TrajectoryTracker.prototype[Symbol.dispose] = TrajectoryTracker.prototype.free;
|
|
|
|
/**
|
|
* WASM-compatible adapter pool wrapper
|
|
*/
|
|
export class WasmAdapterPool {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmAdapterPoolFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmadapterpool_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get or create an adapter for a task type
|
|
* @param {string} task_type
|
|
* @returns {any}
|
|
*/
|
|
getAdapter(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmadapterpool_getAdapter(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get adapter count
|
|
* @returns {number}
|
|
*/
|
|
adapterCount() {
|
|
const ret = wasm.wasmadapterpool_adapterCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Export adapter to bytes for P2P sharing
|
|
* @param {string} task_type
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportAdapter(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmadapterpool_exportAdapter(this.__wbg_ptr, ptr0, len0);
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Import adapter from bytes
|
|
* @param {string} task_type
|
|
* @param {Uint8Array} bytes
|
|
* @returns {boolean}
|
|
*/
|
|
importAdapter(task_type, bytes) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmadapterpool_importAdapter(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Route to best adapter by task embedding
|
|
* @param {Float32Array} task_embedding
|
|
* @returns {any}
|
|
*/
|
|
routeToAdapter(task_embedding) {
|
|
const ptr0 = passArrayF32ToWasm0(task_embedding, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmadapterpool_routeToAdapter(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Create a new adapter pool
|
|
* @param {number} hidden_dim
|
|
* @param {number} max_slots
|
|
*/
|
|
constructor(hidden_dim, max_slots) {
|
|
const ret = wasm.wasmadapterpool_new(hidden_dim, max_slots);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WasmAdapterPoolFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Apply adapter to input
|
|
* @param {string} task_type
|
|
* @param {Float32Array} input
|
|
* @returns {Float32Array}
|
|
*/
|
|
forward(task_type, input) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmadapterpool_forward(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v3;
|
|
}
|
|
/**
|
|
* Get pool statistics
|
|
* @returns {any}
|
|
*/
|
|
getStats() {
|
|
const ret = wasm.wasmadapterpool_getStats(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmAdapterPool.prototype[Symbol.dispose] = WasmAdapterPool.prototype.free;
|
|
|
|
/**
|
|
* Unified interface for all exotic WASM capabilities
|
|
*/
|
|
export class WasmCapabilities {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmCapabilitiesFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmcapabilities_free(ptr, 0);
|
|
}
|
|
/**
|
|
* @returns {boolean}
|
|
*/
|
|
enableHDC() {
|
|
const ret = wasm.wasmcapabilities_enableHDC(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {number} _quorum
|
|
* @returns {boolean}
|
|
*/
|
|
enableNAO(_quorum) {
|
|
const ret = wasm.wasmcapabilities_enableNAO(this.__wbg_ptr, _quorum);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {number} _num_neurons
|
|
* @param {number} _inhibition
|
|
* @param {number} _threshold
|
|
* @returns {boolean}
|
|
*/
|
|
enableWTA(_num_neurons, _inhibition, _threshold) {
|
|
const ret = wasm.wasmcapabilities_enableWTA(this.__wbg_ptr, _num_neurons, _inhibition, _threshold);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {Float32Array} _activations
|
|
* @returns {number}
|
|
*/
|
|
competeWTA(_activations) {
|
|
const ptr0 = passArrayF32ToWasm0(_activations, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_competeWTA(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {number} _input_dim
|
|
* @param {number} _time_constant
|
|
* @returns {boolean}
|
|
*/
|
|
enableBTSP(_input_dim, _time_constant) {
|
|
const ret = wasm.wasmcapabilities_enableBTSP(this.__wbg_ptr, _input_dim, _time_constant);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {string} _proposal_id
|
|
* @returns {boolean}
|
|
*/
|
|
executeNAO(_proposal_id) {
|
|
const ptr0 = passStringToWasm0(_proposal_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_executeNAO(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get a summary of all enabled capabilities
|
|
* @returns {any}
|
|
*/
|
|
getSummary() {
|
|
const ret = wasm.wasmcapabilities_getSummary(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {string} _action
|
|
* @returns {string}
|
|
*/
|
|
proposeNAO(_action) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const ptr0 = passStringToWasm0(_action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_proposeNAO(this.__wbg_ptr, ptr0, len0);
|
|
deferred2_0 = ret[0];
|
|
deferred2_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* @param {Float32Array} _input
|
|
* @returns {number}
|
|
*/
|
|
forwardBTSP(_input) {
|
|
const ptr0 = passArrayF32ToWasm0(_input, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_forwardBTSP(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getNAOSync() {
|
|
const ret = wasm.wasmcapabilities_getNAOSync(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {string} _key
|
|
* @param {number} _threshold
|
|
* @returns {any}
|
|
*/
|
|
retrieveHDC(_key, _threshold) {
|
|
const ptr0 = passStringToWasm0(_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_retrieveHDC(this.__wbg_ptr, ptr0, len0, _threshold);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {string} _member_id
|
|
* @param {bigint} _stake
|
|
* @returns {boolean}
|
|
*/
|
|
addNAOMember(_member_id, _stake) {
|
|
const ptr0 = passStringToWasm0(_member_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_addNAOMember(this.__wbg_ptr, ptr0, len0, _stake);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {string} _operator_type
|
|
* @param {Float32Array} _gradient
|
|
* @returns {boolean}
|
|
*/
|
|
adaptMicroLoRA(_operator_type, _gradient) {
|
|
const ptr0 = passStringToWasm0(_operator_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArrayF32ToWasm0(_gradient, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_adaptMicroLoRA(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {string} _operator_type
|
|
* @param {Float32Array} input
|
|
* @returns {Float32Array}
|
|
*/
|
|
applyMicroLoRA(_operator_type, input) {
|
|
const ptr0 = passStringToWasm0(_operator_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArrayF32ToWasm0(input, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_applyMicroLoRA(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v3;
|
|
}
|
|
/**
|
|
* List all available exotic capabilities
|
|
* @returns {any}
|
|
*/
|
|
getCapabilities() {
|
|
const ret = wasm.wasmcapabilities_getCapabilities(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {number} _dim
|
|
* @param {number} _rank
|
|
* @returns {boolean}
|
|
*/
|
|
enableMicroLoRA(_dim, _rank) {
|
|
const ret = wasm.wasmcapabilities_enableMicroLoRA(this.__wbg_ptr, _dim, _rank);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @returns {any}
|
|
*/
|
|
tickTimeCrystal() {
|
|
const ret = wasm.wasmcapabilities_tickTimeCrystal(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {number} _rate
|
|
*/
|
|
growMorphogenetic(_rate) {
|
|
wasm.wasmcapabilities_growMorphogenetic(this.__wbg_ptr, _rate);
|
|
}
|
|
/**
|
|
* @param {Float32Array} _pattern
|
|
* @param {number} _target
|
|
* @returns {boolean}
|
|
*/
|
|
oneShotAssociate(_pattern, _target) {
|
|
const ptr0 = passArrayF32ToWasm0(_pattern, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_oneShotAssociate(this.__wbg_ptr, ptr0, len0, _target);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {number} _oscillators
|
|
* @param {number} _period_ms
|
|
* @returns {boolean}
|
|
*/
|
|
enableTimeCrystal(_oscillators, _period_ms) {
|
|
const ret = wasm.wasmcapabilities_enableMicroLoRA(this.__wbg_ptr, _oscillators, _period_ms);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {number} _threshold
|
|
*/
|
|
pruneMorphogenetic(_threshold) {
|
|
wasm.wasmcapabilities_growMorphogenetic(this.__wbg_ptr, _threshold);
|
|
}
|
|
/**
|
|
* @param {number} _width
|
|
* @param {number} _height
|
|
* @returns {boolean}
|
|
*/
|
|
enableMorphogenetic(_width, _height) {
|
|
const ret = wasm.wasmcapabilities_enableMicroLoRA(this.__wbg_ptr, _width, _height);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getTimeCrystalSync() {
|
|
const ret = wasm.wasmcapabilities_getNAOSync(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @param {Float32Array} _content
|
|
* @param {number} _salience
|
|
* @param {number} _source_module
|
|
* @returns {boolean}
|
|
*/
|
|
broadcastToWorkspace(_content, _salience, _source_module) {
|
|
const ptr0 = passArrayF32ToWasm0(_content, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_broadcastToWorkspace(this.__wbg_ptr, ptr0, len0, _salience, _source_module);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @returns {any}
|
|
*/
|
|
getWorkspaceContents() {
|
|
const ret = wasm.wasmcapabilities_getWorkspaceContents(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* @returns {boolean}
|
|
*/
|
|
isTimeCrystalStable() {
|
|
const ret = wasm.wasmcapabilities_getMorphogeneticCellCount(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {number} _capacity
|
|
* @returns {boolean}
|
|
*/
|
|
enableGlobalWorkspace(_capacity) {
|
|
const ret = wasm.wasmcapabilities_enableGlobalWorkspace(this.__wbg_ptr, _capacity);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @returns {any}
|
|
*/
|
|
getMorphogeneticStats() {
|
|
const ret = wasm.wasmcapabilities_getMorphogeneticStats(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
differentiateMorphogenetic() {
|
|
wasm.wasmcapabilities_differentiateMorphogenetic(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
*/
|
|
getMorphogeneticCellCount() {
|
|
const ret = wasm.wasmcapabilities_getMorphogeneticCellCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Create a new capabilities manager for a node
|
|
* @param {string} node_id
|
|
*/
|
|
constructor(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_new(ptr0, len0);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WasmCapabilitiesFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Step all enabled capabilities forward (for main loop integration)
|
|
* @param {number} dt
|
|
*/
|
|
step(dt) {
|
|
wasm.wasmcapabilities_growMorphogenetic(this.__wbg_ptr, dt);
|
|
}
|
|
/**
|
|
* @param {number} _dt
|
|
*/
|
|
tickNAO(_dt) {
|
|
wasm.wasmcapabilities_growMorphogenetic(this.__wbg_ptr, _dt);
|
|
}
|
|
/**
|
|
* @param {string} _proposal_id
|
|
* @param {number} _weight
|
|
* @returns {boolean}
|
|
*/
|
|
voteNAO(_proposal_id, _weight) {
|
|
const ptr0 = passStringToWasm0(_proposal_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_voteNAO(this.__wbg_ptr, ptr0, len0, _weight);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* @param {string} _key
|
|
* @returns {boolean}
|
|
*/
|
|
storeHDC(_key) {
|
|
const ptr0 = passStringToWasm0(_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcapabilities_executeNAO(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmCapabilities.prototype[Symbol.dispose] = WasmCapabilities.prototype.free;
|
|
|
|
/**
|
|
* CRDT-based credit ledger for P2P consistency
|
|
*/
|
|
export class WasmCreditLedger {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmCreditLedgerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmcreditledger_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get total spent
|
|
* @returns {bigint}
|
|
*/
|
|
totalSpent() {
|
|
const ret = wasm.wasmcreditledger_totalSpent(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Export spent counter for sync
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportSpent() {
|
|
const ret = wasm.wasmcreditledger_exportSpent(this.__wbg_ptr);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Get total earned (before spending)
|
|
* @returns {bigint}
|
|
*/
|
|
totalEarned() {
|
|
const ret = wasm.wasmcreditledger_totalEarned(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Export earned counter for sync
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportEarned() {
|
|
const ret = wasm.wasmcreditledger_exportEarned(this.__wbg_ptr);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Get staked amount
|
|
* @returns {bigint}
|
|
*/
|
|
stakedAmount() {
|
|
const ret = wasm.wasmcreditledger_stakedAmount(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Get network compute hours (for multiplier)
|
|
* @returns {number}
|
|
*/
|
|
networkCompute() {
|
|
const ret = wasm.wasmcreditledger_networkCompute(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get current multiplier
|
|
* @returns {number}
|
|
*/
|
|
currentMultiplier() {
|
|
const ret = wasm.wasmcreditledger_currentMultiplier(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Update network compute (from P2P sync)
|
|
* @param {number} hours
|
|
*/
|
|
updateNetworkCompute(hours) {
|
|
wasm.wasmcreditledger_updateNetworkCompute(this.__wbg_ptr, hours);
|
|
}
|
|
/**
|
|
* Create a new credit ledger
|
|
* @param {string} node_id
|
|
*/
|
|
constructor(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcreditledger_new(ptr0, len0);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
WasmCreditLedgerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Merge with another ledger (CRDT merge) - optimized batch processing
|
|
* @param {Uint8Array} other_earned
|
|
* @param {Uint8Array} other_spent
|
|
*/
|
|
merge(other_earned, other_spent) {
|
|
const ptr0 = passArray8ToWasm0(other_earned, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(other_spent, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcreditledger_merge(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Slash staked credits (penalty for bad behavior)
|
|
* @param {bigint} amount
|
|
* @returns {bigint}
|
|
*/
|
|
slash(amount) {
|
|
const ret = wasm.wasmcreditledger_slash(this.__wbg_ptr, amount);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return BigInt.asUintN(64, ret[0]);
|
|
}
|
|
/**
|
|
* Stake credits for participation
|
|
* @param {bigint} amount
|
|
*/
|
|
stake(amount) {
|
|
const ret = wasm.wasmcreditledger_stake(this.__wbg_ptr, amount);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Credit the ledger (earn credits)
|
|
* @param {bigint} amount
|
|
* @param {string} reason
|
|
*/
|
|
credit(amount, reason) {
|
|
const ptr0 = passStringToWasm0(reason, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmcreditledger_credit(this.__wbg_ptr, amount, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Deduct from the ledger (spend credits)
|
|
* @param {bigint} amount
|
|
*/
|
|
deduct(amount) {
|
|
const ret = wasm.wasmcreditledger_deduct(this.__wbg_ptr, amount);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Get current balance
|
|
* @returns {bigint}
|
|
*/
|
|
balance() {
|
|
const ret = wasm.wasmcreditledger_balance(this.__wbg_ptr);
|
|
return BigInt.asUintN(64, ret);
|
|
}
|
|
/**
|
|
* Unstake credits
|
|
* @param {bigint} amount
|
|
*/
|
|
unstake(amount) {
|
|
const ret = wasm.wasmcreditledger_unstake(this.__wbg_ptr, amount);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmCreditLedger.prototype[Symbol.dispose] = WasmCreditLedger.prototype.free;
|
|
|
|
/**
|
|
* Idle detection and throttling
|
|
*/
|
|
export class WasmIdleDetector {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmIdleDetectorFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmidledetector_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get status summary
|
|
* @returns {any}
|
|
*/
|
|
getStatus() {
|
|
const ret = wasm.wasmidledetector_getStatus(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Update FPS measurement
|
|
* @param {number} fps
|
|
*/
|
|
updateFps(fps) {
|
|
wasm.wasmidledetector_updateFps(this.__wbg_ptr, fps);
|
|
}
|
|
/**
|
|
* Check if we should be working
|
|
* @returns {boolean}
|
|
*/
|
|
shouldWork() {
|
|
const ret = wasm.wasmidledetector_shouldWork(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get current throttle level (0.0 - max_cpu)
|
|
* @returns {number}
|
|
*/
|
|
getThrottle() {
|
|
const ret = wasm.wasmidledetector_getThrottle(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Record user interaction
|
|
*/
|
|
recordInteraction() {
|
|
wasm.wasmidledetector_recordInteraction(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Set battery status (called from JS)
|
|
* @param {boolean} on_battery
|
|
*/
|
|
setBatteryStatus(on_battery) {
|
|
wasm.wasmidledetector_setBatteryStatus(this.__wbg_ptr, on_battery);
|
|
}
|
|
/**
|
|
* Create a new idle detector
|
|
* @param {number} max_cpu
|
|
* @param {number} min_idle_time
|
|
*/
|
|
constructor(max_cpu, min_idle_time) {
|
|
const ret = wasm.wasmidledetector_new(max_cpu, min_idle_time);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
WasmIdleDetectorFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Stop monitoring
|
|
*/
|
|
stop() {
|
|
wasm.wasmidledetector_stop(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Pause contribution (user-initiated)
|
|
*/
|
|
pause() {
|
|
wasm.wasmidledetector_pause(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Start monitoring
|
|
*/
|
|
start() {
|
|
const ret = wasm.wasmidledetector_start(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Resume contribution
|
|
*/
|
|
resume() {
|
|
wasm.wasmidledetector_resume(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Check if user is idle
|
|
* @returns {boolean}
|
|
*/
|
|
isIdle() {
|
|
const ret = wasm.wasmidledetector_isIdle(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmIdleDetector.prototype[Symbol.dispose] = WasmIdleDetector.prototype.free;
|
|
|
|
/**
|
|
* BroadcastChannel-based transport for multi-tab communication
|
|
*/
|
|
export class WasmMcpBroadcast {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmMcpBroadcastFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmmcpbroadcast_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Set as server mode (responds to requests)
|
|
* @param {WasmMcpServer} server
|
|
*/
|
|
setServer(server) {
|
|
_assertClass(server, WasmMcpServer);
|
|
var ptr0 = server.__destroy_into_raw();
|
|
wasm.wasmmcpbroadcast_setServer(this.__wbg_ptr, ptr0);
|
|
}
|
|
/**
|
|
* Create a broadcast transport
|
|
* @param {string} channel_name
|
|
*/
|
|
constructor(channel_name) {
|
|
const ptr0 = passStringToWasm0(channel_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmmcpbroadcast_new(ptr0, len0);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
WasmMcpBroadcastFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Send a request (client mode)
|
|
* @param {string} request_json
|
|
*/
|
|
send(request_json) {
|
|
const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmmcpbroadcast_send(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Close the channel
|
|
*/
|
|
close() {
|
|
wasm.wasmmcpbroadcast_close(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Start listening for requests (server mode)
|
|
*/
|
|
listen() {
|
|
const ret = wasm.wasmmcpbroadcast_listen(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmMcpBroadcast.prototype[Symbol.dispose] = WasmMcpBroadcast.prototype.free;
|
|
|
|
/**
|
|
* Browser-based MCP server for edge-net
|
|
*
|
|
* Provides Model Context Protocol interface over MessagePort or direct calls.
|
|
* All edge-net capabilities are exposed as MCP tools.
|
|
*/
|
|
export class WasmMcpServer {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(WasmMcpServer.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
WasmMcpServerFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmMcpServerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmmcpserver_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create with custom configuration
|
|
* @param {any} config
|
|
* @returns {WasmMcpServer}
|
|
*/
|
|
static withConfig(config) {
|
|
const ret = wasm.wasmmcpserver_withConfig(config);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return WasmMcpServer.__wrap(ret[0]);
|
|
}
|
|
/**
|
|
* Set identity for authenticated operations
|
|
* @param {WasmNodeIdentity} identity
|
|
*/
|
|
setIdentity(identity) {
|
|
_assertClass(identity, WasmNodeIdentity);
|
|
var ptr0 = identity.__destroy_into_raw();
|
|
wasm.wasmmcpserver_setIdentity(this.__wbg_ptr, ptr0);
|
|
}
|
|
/**
|
|
* Initialize learning engine
|
|
*/
|
|
initLearning() {
|
|
const ret = wasm.wasmmcpserver_initLearning(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Handle an MCP request (JSON string)
|
|
* @param {string} request_json
|
|
* @returns {Promise<string>}
|
|
*/
|
|
handleRequest(request_json) {
|
|
const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmmcpserver_handleRequest(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get server info
|
|
* @returns {any}
|
|
*/
|
|
getServerInfo() {
|
|
const ret = wasm.wasmmcpserver_getServerInfo(this.__wbg_ptr);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Handle MCP request from JsValue (for direct JS calls)
|
|
* @param {any} request
|
|
* @returns {Promise<any>}
|
|
*/
|
|
handleRequestJs(request) {
|
|
const ret = wasm.wasmmcpserver_handleRequestJs(this.__wbg_ptr, request);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Create a new MCP server with default configuration
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.wasmmcpserver_new();
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
WasmMcpServerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmMcpServer.prototype[Symbol.dispose] = WasmMcpServer.prototype.free;
|
|
|
|
/**
|
|
* Browser-based MCP transport using MessagePort
|
|
*/
|
|
export class WasmMcpTransport {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(WasmMcpTransport.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
WasmMcpTransportFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmMcpTransportFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmmcptransport_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create transport from a Worker
|
|
* @param {Worker} worker
|
|
*/
|
|
constructor(worker) {
|
|
const ret = wasm.wasmmcptransport_new(worker);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
WasmMcpTransportFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Initialize transport (set up message handler)
|
|
*/
|
|
init() {
|
|
const ret = wasm.wasmmcptransport_init(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Send an MCP request and get a Promise for the response
|
|
* @param {any} request
|
|
* @returns {Promise<any>}
|
|
*/
|
|
send(request) {
|
|
const ret = wasm.wasmmcptransport_send(this.__wbg_ptr, request);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Close the transport
|
|
*/
|
|
close() {
|
|
wasm.wasmmcptransport_close(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Create transport from existing MessagePort
|
|
* @param {MessagePort} port
|
|
* @returns {WasmMcpTransport}
|
|
*/
|
|
static fromPort(port) {
|
|
const ret = wasm.wasmmcptransport_fromPort(port);
|
|
return WasmMcpTransport.__wrap(ret);
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmMcpTransport.prototype[Symbol.dispose] = WasmMcpTransport.prototype.free;
|
|
|
|
/**
|
|
* Worker-side handler for MCP requests
|
|
*/
|
|
export class WasmMcpWorkerHandler {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmMcpWorkerHandlerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmmcpworkerhandler_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create handler with MCP server
|
|
* @param {WasmMcpServer} server
|
|
*/
|
|
constructor(server) {
|
|
_assertClass(server, WasmMcpServer);
|
|
var ptr0 = server.__destroy_into_raw();
|
|
const ret = wasm.wasmmcpworkerhandler_new(ptr0);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WasmMcpWorkerHandlerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Start handling messages (call in worker)
|
|
*/
|
|
start() {
|
|
const ret = wasm.wasmmcpworkerhandler_start(this.__wbg_ptr);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmMcpWorkerHandler.prototype[Symbol.dispose] = WasmMcpWorkerHandler.prototype.free;
|
|
|
|
/**
|
|
* P2P network manager
|
|
*/
|
|
export class WasmNetworkManager {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmNetworkManagerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmnetworkmanager_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get peer count
|
|
* @returns {number}
|
|
*/
|
|
peerCount() {
|
|
const ret = wasm.wasmnetworkmanager_peerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Check if connected
|
|
* @returns {boolean}
|
|
*/
|
|
isConnected() {
|
|
const ret = wasm.wasmnetworkmanager_isConnected(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Register a peer
|
|
* @param {string} node_id
|
|
* @param {Uint8Array} pubkey
|
|
* @param {string[]} capabilities
|
|
* @param {bigint} stake
|
|
*/
|
|
registerPeer(node_id, pubkey, capabilities, stake) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(pubkey, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passArrayJsValueToWasm0(capabilities, wasm.__wbindgen_malloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
wasm.wasmnetworkmanager_registerPeer(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, stake);
|
|
}
|
|
/**
|
|
* Select workers for task execution (reputation-weighted random)
|
|
* @param {string} capability
|
|
* @param {number} count
|
|
* @returns {string[]}
|
|
*/
|
|
selectWorkers(capability, count) {
|
|
const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnetworkmanager_selectWorkers(this.__wbg_ptr, ptr0, len0, count);
|
|
var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Get active peer count (seen in last 60s)
|
|
* @returns {number}
|
|
*/
|
|
activePeerCount() {
|
|
const ret = wasm.wasmnetworkmanager_activePeerCount(this.__wbg_ptr);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Update peer reputation
|
|
* @param {string} node_id
|
|
* @param {number} delta
|
|
*/
|
|
updateReputation(node_id, delta) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.wasmnetworkmanager_updateReputation(this.__wbg_ptr, ptr0, len0, delta);
|
|
}
|
|
/**
|
|
* Get peers with specific capability
|
|
* @param {string} capability
|
|
* @returns {string[]}
|
|
*/
|
|
getPeersWithCapability(capability) {
|
|
const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnetworkmanager_getPeersWithCapability(this.__wbg_ptr, ptr0, len0);
|
|
var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
return v2;
|
|
}
|
|
/**
|
|
* @param {string} node_id
|
|
*/
|
|
constructor(node_id) {
|
|
const ptr0 = passStringToWasm0(node_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnetworkmanager_new(ptr0, len0);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WasmNetworkManagerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Add a relay URL
|
|
* @param {string} url
|
|
*/
|
|
addRelay(url) {
|
|
const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.wasmnetworkmanager_addRelay(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmNetworkManager.prototype[Symbol.dispose] = WasmNetworkManager.prototype.free;
|
|
|
|
/**
|
|
* Node identity with Ed25519 keypair
|
|
*/
|
|
export class WasmNodeIdentity {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(WasmNodeIdentity.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
WasmNodeIdentityFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmNodeIdentityFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmnodeidentity_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Verify a signature from another node
|
|
* @param {Uint8Array} public_key
|
|
* @param {Uint8Array} message
|
|
* @param {Uint8Array} signature
|
|
* @returns {boolean}
|
|
*/
|
|
static verifyFrom(public_key, message, signature) {
|
|
const ptr0 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_verifyFrom(ptr0, len0, ptr1, len1, ptr2, len2);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get the public key as hex string
|
|
* @returns {string}
|
|
*/
|
|
publicKeyHex() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.wasmnodeidentity_publicKeyHex(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Restore identity from secret key bytes
|
|
* @param {Uint8Array} secret_key
|
|
* @param {string} site_id
|
|
* @returns {WasmNodeIdentity}
|
|
*/
|
|
static fromSecretKey(secret_key, site_id) {
|
|
const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(site_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_fromSecretKey(ptr0, len0, ptr1, len1);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return WasmNodeIdentity.__wrap(ret[0]);
|
|
}
|
|
/**
|
|
* Get browser fingerprint
|
|
* @returns {string | undefined}
|
|
*/
|
|
getFingerprint() {
|
|
const ret = wasm.wasmnodeidentity_getFingerprint(this.__wbg_ptr);
|
|
let v1;
|
|
if (ret[0] !== 0) {
|
|
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
}
|
|
return v1;
|
|
}
|
|
/**
|
|
* Set browser fingerprint for anti-sybil
|
|
* @param {string} fingerprint
|
|
*/
|
|
setFingerprint(fingerprint) {
|
|
const ptr0 = passStringToWasm0(fingerprint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.wasmnodeidentity_setFingerprint(this.__wbg_ptr, ptr0, len0);
|
|
}
|
|
/**
|
|
* Get the public key as bytes
|
|
* @returns {Uint8Array}
|
|
*/
|
|
publicKeyBytes() {
|
|
const ret = wasm.wasmnodeidentity_publicKeyBytes(this.__wbg_ptr);
|
|
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v1;
|
|
}
|
|
/**
|
|
* Export secret key encrypted with password (secure backup)
|
|
* Uses Argon2id for key derivation and AES-256-GCM for encryption
|
|
* @param {string} password
|
|
* @returns {Uint8Array}
|
|
*/
|
|
exportSecretKey(password) {
|
|
const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_exportSecretKey(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[3]) {
|
|
throw takeFromExternrefTable0(ret[2]);
|
|
}
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Import secret key from encrypted backup
|
|
* @param {Uint8Array} encrypted
|
|
* @param {string} password
|
|
* @param {string} site_id
|
|
* @returns {WasmNodeIdentity}
|
|
*/
|
|
static importSecretKey(encrypted, password, site_id) {
|
|
const ptr0 = passArray8ToWasm0(encrypted, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ptr2 = passStringToWasm0(site_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len2 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_importSecretKey(ptr0, len0, ptr1, len1, ptr2, len2);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return WasmNodeIdentity.__wrap(ret[0]);
|
|
}
|
|
/**
|
|
* Sign a message
|
|
* @param {Uint8Array} message
|
|
* @returns {Uint8Array}
|
|
*/
|
|
sign(message) {
|
|
const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_sign(this.__wbg_ptr, ptr0, len0);
|
|
var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
return v2;
|
|
}
|
|
/**
|
|
* Verify a signature
|
|
* @param {Uint8Array} message
|
|
* @param {Uint8Array} signature
|
|
* @returns {boolean}
|
|
*/
|
|
verify(message, signature) {
|
|
const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_verify(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get the node's unique identifier
|
|
* @returns {string}
|
|
*/
|
|
nodeId() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.wasmnodeidentity_nodeId(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get the site ID
|
|
* @returns {string}
|
|
*/
|
|
siteId() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.wasmnodeidentity_siteId(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Generate a new node identity
|
|
* @param {string} site_id
|
|
* @returns {WasmNodeIdentity}
|
|
*/
|
|
static generate(site_id) {
|
|
const ptr0 = passStringToWasm0(site_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmnodeidentity_generate(ptr0, len0);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
return WasmNodeIdentity.__wrap(ret[0]);
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmNodeIdentity.prototype[Symbol.dispose] = WasmNodeIdentity.prototype.free;
|
|
|
|
/**
|
|
* WASM-bindgen wrapper for stigmergy coordination
|
|
*/
|
|
export class WasmStigmergy {
|
|
static __wrap(ptr) {
|
|
ptr = ptr >>> 0;
|
|
const obj = Object.create(WasmStigmergy.prototype);
|
|
obj.__wbg_ptr = ptr;
|
|
WasmStigmergyFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
return obj;
|
|
}
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmStigmergyFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmstigmergy_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Create with custom parameters
|
|
* @param {number} decay_rate
|
|
* @param {number} deposit_rate
|
|
* @param {number} evaporation_hours
|
|
* @returns {WasmStigmergy}
|
|
*/
|
|
static withParams(decay_rate, deposit_rate, evaporation_hours) {
|
|
const ret = wasm.wasmstigmergy_withParams(decay_rate, deposit_rate, evaporation_hours);
|
|
return WasmStigmergy.__wrap(ret);
|
|
}
|
|
/**
|
|
* Export current state for P2P sharing
|
|
* @returns {string}
|
|
*/
|
|
exportState() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.wasmstigmergy_exportState(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get raw pheromone intensity
|
|
* @param {string} task_type
|
|
* @returns {number}
|
|
*/
|
|
getIntensity(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmstigmergy_getIntensity(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Set minimum stake for anti-sybil
|
|
* @param {bigint} min_stake
|
|
*/
|
|
setMinStake(min_stake) {
|
|
wasm.wasmstigmergy_setMinStake(this.__wbg_ptr, min_stake);
|
|
}
|
|
/**
|
|
* Should this node accept a task? (combined decision)
|
|
* @param {string} task_type
|
|
* @returns {number}
|
|
*/
|
|
shouldAccept(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmstigmergy_shouldAccept(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check and run evaporation if due
|
|
* @returns {boolean}
|
|
*/
|
|
maybeEvaporate() {
|
|
const ret = wasm.wasmstigmergy_maybeEvaporate(this.__wbg_ptr);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get all task types ranked by attractiveness
|
|
* @returns {string}
|
|
*/
|
|
getRankedTasks() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.wasmstigmergy_getRankedTasks(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
/**
|
|
* Get success rate for a task type
|
|
* @param {string} task_type
|
|
* @returns {number}
|
|
*/
|
|
getSuccessRate(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmstigmergy_getSuccessRate(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Get node's specialization score
|
|
* @param {string} task_type
|
|
* @returns {number}
|
|
*/
|
|
getSpecialization(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmstigmergy_getSpecialization(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Deposit with success/failure outcome
|
|
* @param {string} task_type
|
|
* @param {string} peer_id
|
|
* @param {boolean} success
|
|
* @param {bigint} stake
|
|
*/
|
|
depositWithOutcome(task_type, peer_id, success, stake) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.wasmstigmergy_depositWithOutcome(this.__wbg_ptr, ptr0, len0, ptr1, len1, success, stake);
|
|
}
|
|
/**
|
|
* Update node specialization based on outcome
|
|
* @param {string} task_type
|
|
* @param {boolean} success
|
|
*/
|
|
updateSpecialization(task_type, success) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.wasmstigmergy_updateSpecialization(this.__wbg_ptr, ptr0, len0, success);
|
|
}
|
|
/**
|
|
* Get best specialization recommendation
|
|
* @returns {string | undefined}
|
|
*/
|
|
getBestSpecialization() {
|
|
const ret = wasm.wasmstigmergy_getBestSpecialization(this.__wbg_ptr);
|
|
let v1;
|
|
if (ret[0] !== 0) {
|
|
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
}
|
|
return v1;
|
|
}
|
|
/**
|
|
* Create a new stigmergy engine
|
|
*/
|
|
constructor() {
|
|
const ret = wasm.wasmstigmergy_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WasmStigmergyFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Merge peer pheromone state (JSON format)
|
|
* @param {string} peer_state_json
|
|
* @returns {boolean}
|
|
*/
|
|
merge(peer_state_json) {
|
|
const ptr0 = passStringToWasm0(peer_state_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmstigmergy_merge(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Get acceptance probability for a task type
|
|
* @param {string} task_type
|
|
* @returns {number}
|
|
*/
|
|
follow(task_type) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmstigmergy_follow(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Deposit pheromone after task completion
|
|
* @param {string} task_type
|
|
* @param {string} peer_id
|
|
* @param {number} success_rate
|
|
* @param {bigint} stake
|
|
*/
|
|
deposit(task_type, peer_id, success_rate, stake) {
|
|
const ptr0 = passStringToWasm0(task_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.wasmstigmergy_deposit(this.__wbg_ptr, ptr0, len0, ptr1, len1, success_rate, stake);
|
|
}
|
|
/**
|
|
* Run evaporation (call periodically)
|
|
*/
|
|
evaporate() {
|
|
wasm.wasmstigmergy_evaporate(this.__wbg_ptr);
|
|
}
|
|
/**
|
|
* Get statistics as JSON
|
|
* @returns {string}
|
|
*/
|
|
getStats() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const ret = wasm.wasmstigmergy_getStats(this.__wbg_ptr);
|
|
deferred1_0 = ret[0];
|
|
deferred1_1 = ret[1];
|
|
return getStringFromWasm0(ret[0], ret[1]);
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmStigmergy.prototype[Symbol.dispose] = WasmStigmergy.prototype.free;
|
|
|
|
/**
|
|
* Sandboxed task executor
|
|
*/
|
|
export class WasmTaskExecutor {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmTaskExecutorFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmtaskexecutor_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Set encryption key for payload decryption
|
|
* @param {Uint8Array} key
|
|
*/
|
|
setTaskKey(key) {
|
|
const ptr0 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.wasmtaskexecutor_setTaskKey(this.__wbg_ptr, ptr0, len0);
|
|
if (ret[1]) {
|
|
throw takeFromExternrefTable0(ret[0]);
|
|
}
|
|
}
|
|
/**
|
|
* Create a new task executor
|
|
* @param {number} max_memory
|
|
*/
|
|
constructor(max_memory) {
|
|
const ret = wasm.wasmtaskexecutor_new(max_memory);
|
|
if (ret[2]) {
|
|
throw takeFromExternrefTable0(ret[1]);
|
|
}
|
|
this.__wbg_ptr = ret[0] >>> 0;
|
|
WasmTaskExecutorFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmTaskExecutor.prototype[Symbol.dispose] = WasmTaskExecutor.prototype.free;
|
|
|
|
/**
|
|
* Task queue for P2P distribution - optimized with priority heap
|
|
*/
|
|
export class WasmTaskQueue {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmTaskQueueFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmtaskqueue_free(ptr, 0);
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmTaskQueue.prototype[Symbol.dispose] = WasmTaskQueue.prototype.free;
|
|
|
|
/**
|
|
* Work scheduler for distributing compute across frames
|
|
*/
|
|
export class WasmWorkScheduler {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WasmWorkSchedulerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_wasmworkscheduler_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Calculate how many tasks to run this frame
|
|
* @param {number} throttle
|
|
* @returns {number}
|
|
*/
|
|
tasksThisFrame(throttle) {
|
|
const ret = wasm.wasmworkscheduler_tasksThisFrame(this.__wbg_ptr, throttle);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Set pending task count
|
|
* @param {number} count
|
|
*/
|
|
setPendingTasks(count) {
|
|
wasm.wasmworkscheduler_setPendingTasks(this.__wbg_ptr, count);
|
|
}
|
|
/**
|
|
* Record task completion for averaging
|
|
* @param {number} duration_ms
|
|
*/
|
|
recordTaskDuration(duration_ms) {
|
|
wasm.wasmworkscheduler_recordTaskDuration(this.__wbg_ptr, duration_ms);
|
|
}
|
|
constructor() {
|
|
const ret = wasm.wasmworkscheduler_new();
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WasmWorkSchedulerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WasmWorkScheduler.prototype[Symbol.dispose] = WasmWorkScheduler.prototype.free;
|
|
|
|
/**
|
|
* Manages witness tracking for claims
|
|
*/
|
|
export class WitnessTracker {
|
|
__destroy_into_raw() {
|
|
const ptr = this.__wbg_ptr;
|
|
this.__wbg_ptr = 0;
|
|
WitnessTrackerFinalization.unregister(this);
|
|
return ptr;
|
|
}
|
|
free() {
|
|
const ptr = this.__destroy_into_raw();
|
|
wasm.__wbg_witnesstracker_free(ptr, 0);
|
|
}
|
|
/**
|
|
* Get witness count for a claim
|
|
* @param {string} claim_id
|
|
* @returns {number}
|
|
*/
|
|
witnessCount(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.witnesstracker_witnessCount(this.__wbg_ptr, ptr0, len0);
|
|
return ret >>> 0;
|
|
}
|
|
/**
|
|
* Get confidence score based on witness diversity
|
|
* @param {string} claim_id
|
|
* @returns {number}
|
|
*/
|
|
witnessConfidence(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.witnesstracker_witnessConfidence(this.__wbg_ptr, ptr0, len0);
|
|
return ret;
|
|
}
|
|
/**
|
|
* Check if claim has sufficient independent witnesses
|
|
* @param {string} claim_id
|
|
* @returns {boolean}
|
|
*/
|
|
hasSufficientWitnesses(claim_id) {
|
|
const ptr0 = passStringToWasm0(claim_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ret = wasm.witnesstracker_hasSufficientWitnesses(this.__wbg_ptr, ptr0, len0);
|
|
return ret !== 0;
|
|
}
|
|
/**
|
|
* Create a new witness tracker
|
|
* @param {number} min_witnesses
|
|
*/
|
|
constructor(min_witnesses) {
|
|
const ret = wasm.witnesstracker_new(min_witnesses);
|
|
this.__wbg_ptr = ret >>> 0;
|
|
WitnessTrackerFinalization.register(this, this.__wbg_ptr, this);
|
|
return this;
|
|
}
|
|
}
|
|
if (Symbol.dispose) WitnessTracker.prototype[Symbol.dispose] = WitnessTracker.prototype.free;
|
|
|
|
/**
|
|
* Initialize panic hook for better error messages in console
|
|
*/
|
|
export function init_panic_hook() {
|
|
wasm.init_panic_hook();
|
|
}
|
|
|
|
const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
|
|
|
|
async function __wbg_load(module, imports) {
|
|
if (typeof Response === 'function' && module instanceof Response) {
|
|
if (typeof WebAssembly.instantiateStreaming === 'function') {
|
|
try {
|
|
return await WebAssembly.instantiateStreaming(module, imports);
|
|
} catch (e) {
|
|
const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
|
|
|
|
if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
|
|
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
|
|
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
const bytes = await module.arrayBuffer();
|
|
return await WebAssembly.instantiate(bytes, imports);
|
|
} else {
|
|
const instance = await WebAssembly.instantiate(module, imports);
|
|
|
|
if (instance instanceof WebAssembly.Instance) {
|
|
return { instance, module };
|
|
} else {
|
|
return instance;
|
|
}
|
|
}
|
|
}
|
|
|
|
function __wbg_get_imports() {
|
|
const imports = {};
|
|
imports.wbg = {};
|
|
imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
|
|
const ret = Error(getStringFromWasm0(arg0, arg1));
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
|
|
const ret = Number(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
|
|
const ret = String(arg1);
|
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
};
|
|
imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
|
|
const v = arg1;
|
|
const ret = typeof(v) === 'bigint' ? v : undefined;
|
|
getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
};
|
|
imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
|
|
const v = arg0;
|
|
const ret = typeof(v) === 'boolean' ? v : undefined;
|
|
return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
|
|
const ret = debugString(arg1);
|
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
};
|
|
imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
|
|
const ret = arg0 in arg1;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
|
|
const ret = typeof(arg0) === 'bigint';
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
|
|
const ret = typeof(arg0) === 'function';
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
|
|
const val = arg0;
|
|
const ret = typeof(val) === 'object' && val !== null;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
|
|
const ret = typeof(arg0) === 'string';
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
|
|
const ret = arg0 === undefined;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
|
|
const ret = arg0 === arg1;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
|
|
const ret = arg0 == arg1;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
|
|
const obj = arg1;
|
|
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
};
|
|
imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
|
|
const obj = arg1;
|
|
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
var len1 = WASM_VECTOR_LEN;
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
};
|
|
imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
|
|
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
};
|
|
imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
|
|
arg0._wbg_cb_unref();
|
|
};
|
|
imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
|
|
const ret = arg0.call(arg1, arg2);
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
|
|
const ret = arg0.call(arg1);
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_close_8158530fc398ee2f = function(arg0) {
|
|
arg0.close();
|
|
};
|
|
imports.wbg.__wbg_close_c956ddbf0426a990 = function(arg0) {
|
|
arg0.close();
|
|
};
|
|
imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
|
|
const ret = arg0.crypto;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_data_8bf4ae669a78a688 = function(arg0) {
|
|
const ret = arg0.data;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
|
|
const ret = arg0.done;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
|
|
const ret = Object.entries(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
|
|
let deferred0_0;
|
|
let deferred0_1;
|
|
try {
|
|
deferred0_0 = arg0;
|
|
deferred0_1 = arg1;
|
|
console.error(getStringFromWasm0(arg0, arg1));
|
|
} finally {
|
|
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
}
|
|
};
|
|
imports.wbg.__wbg_getDate_b8071ea9fc4f6838 = function(arg0) {
|
|
const ret = arg0.getDate();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_getDay_c13a50561112f77a = function(arg0) {
|
|
const ret = arg0.getDay();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_getMonth_48a392071f9e5017 = function(arg0) {
|
|
const ret = arg0.getMonth();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_getRandomValues_9b655bdd369112f2 = function() { return handleError(function (arg0, arg1) {
|
|
globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
|
|
}, arguments) };
|
|
imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
|
|
arg0.getRandomValues(arg1);
|
|
}, arguments) };
|
|
imports.wbg.__wbg_getTimezoneOffset_45389e26d6f46823 = function(arg0) {
|
|
const ret = arg0.getTimezoneOffset();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
|
|
const ret = arg0[arg1 >>> 0];
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
|
|
const ret = Reflect.get(arg0, arg1);
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
|
|
const ret = arg0[arg1];
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_hardwareConcurrency_11023a850a093b20 = function(arg0) {
|
|
const ret = arg0.hardwareConcurrency;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_height_5405e57b18dddece = function() { return handleError(function (arg0) {
|
|
const ret = arg0.height;
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
|
|
let result;
|
|
try {
|
|
result = arg0 instanceof ArrayBuffer;
|
|
} catch (_) {
|
|
result = false;
|
|
}
|
|
const ret = result;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_instanceof_Map_084be8da74364158 = function(arg0) {
|
|
let result;
|
|
try {
|
|
result = arg0 instanceof Map;
|
|
} catch (_) {
|
|
result = false;
|
|
}
|
|
const ret = result;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_instanceof_MessagePort_c6d647a8cffdd1a6 = function(arg0) {
|
|
let result;
|
|
try {
|
|
result = arg0 instanceof MessagePort;
|
|
} catch (_) {
|
|
result = false;
|
|
}
|
|
const ret = result;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
|
|
let result;
|
|
try {
|
|
result = arg0 instanceof Uint8Array;
|
|
} catch (_) {
|
|
result = false;
|
|
}
|
|
const ret = result;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_instanceof_Window_b5cf7783caa68180 = function(arg0) {
|
|
let result;
|
|
try {
|
|
result = arg0 instanceof Window;
|
|
} catch (_) {
|
|
result = false;
|
|
}
|
|
const ret = result;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
|
|
const ret = Array.isArray(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
|
|
const ret = Number.isSafeInteger(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
|
|
const ret = Symbol.iterator;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_language_763ea76470ed849b = function(arg0, arg1) {
|
|
const ret = arg1.language;
|
|
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
var len1 = WASM_VECTOR_LEN;
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
};
|
|
imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
|
|
const ret = arg0.length;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
|
|
const ret = arg0.length;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
|
|
const ret = arg0.msCrypto;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_navigator_b49edef831236138 = function(arg0) {
|
|
const ret = arg0.navigator;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_0_23cedd11d9b40c9d = function() {
|
|
const ret = new Date();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_137453588c393c59 = function() { return handleError(function () {
|
|
const ret = new MessageChannel();
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
|
|
const ret = new Object();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_25f239778d6112b9 = function() {
|
|
const ret = new Array();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
|
|
const ret = new Uint8Array(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
|
|
const ret = new Error();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_b2db8aa2650f793a = function(arg0) {
|
|
const ret = new Date(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_b3dd747604c3c93e = function() { return handleError(function (arg0, arg1) {
|
|
const ret = new BroadcastChannel(getStringFromWasm0(arg0, arg1));
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_new_b546ae120718850e = function() {
|
|
const ret = new Map();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
|
|
try {
|
|
var state0 = {a: arg0, b: arg1};
|
|
var cb0 = (arg0, arg1) => {
|
|
const a = state0.a;
|
|
state0.a = 0;
|
|
try {
|
|
return wasm_bindgen__convert__closures_____invoke__h094c87b54a975e5a(a, state0.b, arg0, arg1);
|
|
} finally {
|
|
state0.a = a;
|
|
}
|
|
};
|
|
const ret = new Promise(cb0);
|
|
return ret;
|
|
} finally {
|
|
state0.a = state0.b = 0;
|
|
}
|
|
};
|
|
imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
|
|
const ret = new Function(getStringFromWasm0(arg0, arg1));
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
|
|
const ret = new Uint8Array(arg0 >>> 0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
|
|
const ret = arg0.next;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
|
|
const ret = arg0.next();
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
|
|
const ret = arg0.node;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_now_69d776cd24f5215b = function() {
|
|
const ret = Date.now();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_platform_c9dd29375c0e6694 = function() { return handleError(function (arg0, arg1) {
|
|
const ret = arg1.platform;
|
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
}, arguments) };
|
|
imports.wbg.__wbg_port1_75dce9d0d8087125 = function(arg0) {
|
|
const ret = arg0.port1;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_port2_3cffa4119380f41d = function(arg0) {
|
|
const ret = arg0.port2;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_postMessage_79f844174f56304f = function() { return handleError(function (arg0, arg1) {
|
|
arg0.postMessage(arg1);
|
|
}, arguments) };
|
|
imports.wbg.__wbg_postMessage_e0309b53c7ad30e6 = function() { return handleError(function (arg0, arg1, arg2) {
|
|
arg0.postMessage(arg1, arg2);
|
|
}, arguments) };
|
|
imports.wbg.__wbg_postMessage_ee7b4e76cd1ed685 = function() { return handleError(function (arg0, arg1) {
|
|
arg0.postMessage(arg1);
|
|
}, arguments) };
|
|
imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
|
|
const ret = arg0.process;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
|
|
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
};
|
|
imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
|
|
const ret = arg0.push(arg1);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
|
|
const ret = arg0.queueMicrotask;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_queueMicrotask_fca69f5bfad613a5 = function(arg0) {
|
|
queueMicrotask(arg0);
|
|
};
|
|
imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
|
|
arg0.randomFillSync(arg1);
|
|
}, arguments) };
|
|
imports.wbg.__wbg_random_cc1f9237d866d212 = function() {
|
|
const ret = Math.random();
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
|
|
const ret = module.require;
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
|
|
const ret = Promise.resolve(arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_screen_7c5162a9a6fa46ee = function() { return handleError(function (arg0) {
|
|
const ret = arg0.screen;
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
|
|
arg0[arg1] = arg2;
|
|
};
|
|
imports.wbg.__wbg_set_781438a03c0c3c81 = function() { return handleError(function (arg0, arg1, arg2) {
|
|
const ret = Reflect.set(arg0, arg1, arg2);
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
|
|
arg0[arg1 >>> 0] = arg2;
|
|
};
|
|
imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
|
|
const ret = arg0.set(arg1, arg2);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_set_onmessage_6fa00f5d8f1c055a = function(arg0, arg1) {
|
|
arg0.onmessage = arg1;
|
|
};
|
|
imports.wbg.__wbg_set_onmessage_f0d5bf805190d1d8 = function(arg0, arg1) {
|
|
arg0.onmessage = arg1;
|
|
};
|
|
imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
|
|
const ret = arg1.stack;
|
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
};
|
|
imports.wbg.__wbg_start_dd05b3be5674e9f3 = function(arg0) {
|
|
arg0.start();
|
|
};
|
|
imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
|
|
const ret = typeof global === 'undefined' ? null : global;
|
|
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
};
|
|
imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
|
|
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
};
|
|
imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
|
|
const ret = typeof self === 'undefined' ? null : self;
|
|
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
};
|
|
imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
|
|
const ret = typeof window === 'undefined' ? null : window;
|
|
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
};
|
|
imports.wbg.__wbg_subarray_845f2f5bce7d061a = function(arg0, arg1, arg2) {
|
|
const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
|
|
const ret = arg0.then(arg1);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
|
|
const ret = arg0.value;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
|
|
const ret = arg0.versions;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbg_width_b8c97f5d3a7f759c = function() { return handleError(function (arg0) {
|
|
const ret = arg0.width;
|
|
return ret;
|
|
}, arguments) };
|
|
imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
|
|
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
const ret = getStringFromWasm0(arg0, arg1);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
|
|
// Cast intrinsic for `U64 -> Externref`.
|
|
const ret = BigInt.asUintN(64, arg0);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_cast_46d6ccd6e2a13afa = function(arg0, arg1) {
|
|
// Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h16844f6554aa4052, wasm_bindgen__convert__closures_____invoke__h8c81ca6cba4eba00);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_cast_6ad6aa2864ac3163 = function(arg0, arg1) {
|
|
// Cast intrinsic for `Closure(Closure { dtor_idx: 185, function: Function { arguments: [Externref], shim_idx: 186, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h5a0fd3a052925ed0, wasm_bindgen__convert__closures_____invoke__h9a454594a18d3e6f);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
|
|
// Cast intrinsic for `I64 -> Externref`.
|
|
const ret = arg0;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
|
|
// Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
|
|
const ret = getArrayU8FromWasm0(arg0, arg1);
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
|
|
// Cast intrinsic for `F64 -> Externref`.
|
|
const ret = arg0;
|
|
return ret;
|
|
};
|
|
imports.wbg.__wbindgen_init_externref_table = function() {
|
|
const table = wasm.__wbindgen_externrefs;
|
|
const offset = table.grow(4);
|
|
table.set(0, undefined);
|
|
table.set(offset + 0, undefined);
|
|
table.set(offset + 1, null);
|
|
table.set(offset + 2, true);
|
|
table.set(offset + 3, false);
|
|
};
|
|
|
|
return imports;
|
|
}
|
|
|
|
function __wbg_finalize_init(instance, module) {
|
|
wasm = instance.exports;
|
|
__wbg_init.__wbindgen_wasm_module = module;
|
|
cachedDataViewMemory0 = null;
|
|
cachedFloat32ArrayMemory0 = null;
|
|
cachedUint8ArrayMemory0 = null;
|
|
|
|
|
|
wasm.__wbindgen_start();
|
|
return wasm;
|
|
}
|
|
|
|
function initSync(module) {
|
|
if (wasm !== undefined) return wasm;
|
|
|
|
|
|
if (typeof module !== 'undefined') {
|
|
if (Object.getPrototypeOf(module) === Object.prototype) {
|
|
({module} = module)
|
|
} else {
|
|
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
|
|
}
|
|
}
|
|
|
|
const imports = __wbg_get_imports();
|
|
if (!(module instanceof WebAssembly.Module)) {
|
|
module = new WebAssembly.Module(module);
|
|
}
|
|
const instance = new WebAssembly.Instance(module, imports);
|
|
return __wbg_finalize_init(instance, module);
|
|
}
|
|
|
|
async function __wbg_init(module_or_path) {
|
|
if (wasm !== undefined) return wasm;
|
|
|
|
|
|
if (typeof module_or_path !== 'undefined') {
|
|
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
|
|
({module_or_path} = module_or_path)
|
|
} else {
|
|
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
|
|
}
|
|
}
|
|
|
|
if (typeof module_or_path === 'undefined') {
|
|
module_or_path = new URL('ruvector_edge_net_bg.wasm', import.meta.url);
|
|
}
|
|
const imports = __wbg_get_imports();
|
|
|
|
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
|
|
module_or_path = fetch(module_or_path);
|
|
}
|
|
|
|
const { instance, module } = await __wbg_load(await module_or_path, imports);
|
|
|
|
return __wbg_finalize_init(instance, module);
|
|
}
|
|
|
|
export { initSync };
|
|
export default __wbg_init;
|