@jamscript/client 0.1.0-rc.1

package/dist/client.js

@@ -0,0 +1,339 @@
+import { actionByName, queryByName, stateByName } from "./abi.js";
+import { decodeStateValue, decodeValue, encodeActionPayload, encodeValue } from "./codec.js";
+import { actionSelector, encodeSignedActionV1, encodeSignedActionV2, MANAGED_STATE_COMMITMENT_KEY_V1, nonceKey, ownershipNonceKey, parseHex, signingDigestV1, signingMessageV2, stateKey, toHex, } from "./crypto.js";
+import { asWorkRpc, RpcError } from "./rpc.js";
+import { blake2AsU8a } from "@polkadot/util-crypto";
+import { verifyManagedStateProof } from "./proof.js";
+import { ProofStateProvider, TrustedStateProvider, } from "./state-provider.js";
+const EMPTY_STATE_ROOT_V1 = "0x03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314";
+export class JamScriptClient {
+    deployment;
+    options;
+    rpc;
+    actionHashes = new Map();
+    nextNonces = new Map();
+    nonceTails = new Map();
+    ownershipTails = new Map();
+    constructor(deployment, transport, options = {}) {
+        this.deployment = deployment;
+        this.options = options;
+        if (deployment.abiVersion !== 1 || deployment.abi.abiVersion !== 1) {
+            throw new Error("unsupported JamScript ABI version");
+        }
+        this.rpc = asWorkRpc(transport);
+        this.stateProvider = options.stateProvider
+            ?? (options.stateVerification === "proof"
+                ? new ProofStateProvider(transport)
+                : new TrustedStateProvider(transport));
+        this.verifyProofs = options.stateProvider !== undefined || options.stateVerification === "proof";
+    }
+    stateProvider;
+    verifyProofs;
+    async validateDeployment() {
+        const genesis = await this.rpc.genesisHash();
+        if (!sameHex(genesis, this.deployment.genesisHash)) {
+            throw new Error("deployment genesis hash does not match the chain");
+        }
+    }
+    async readNonce(publicKey, context) {
+        if (publicKey.length !== 32)
+            throw new Error("sr25519 public key must be 32 bytes");
+        const finalized = context ?? (await this.rpc.finalizedContext());
+        const root = await this.managedStateRoot(finalized);
+        const key = nonceKey(publicKey);
+        const valueBytes = await this.readManagedValue(root, key);
+        if (valueBytes === null)
+            return 0n;
+        const value = decodeValue("u64", valueBytes);
+        if (typeof value !== "bigint")
+            throw new Error("nonce storage is not u64");
+        return value;
+    }
+    async submitAction(actionName, input, signer, options = {}) {
+        if (signer.publicKey.length !== 32)
+            throw new Error("sr25519 public key must be 32 bytes");
+        const signerKey = toHex(signer.publicKey).toLowerCase();
+        const prepared = await this.prepareAction(actionName, input, signer, options);
+        let submitted;
+        try {
+            submitted = await this.rpc.submitTransaction(prepared.request);
+        }
+        catch (error) {
+            // Only rewind a reservation when no later concurrent action has already
+            // reserved a nonce.  This keeps the common single-admission-failure
+            // recovery while avoiding duplicate nonces for an active batch.
+            if (this.nextNonces.get(signerKey) === prepared.nonce + 1n) {
+                this.nextNonces.delete(signerKey);
+            }
+            throw error;
+        }
+        this.actionHashes.set(submitted.transactionId.toLowerCase(), prepared.actionHash);
+        return { ...submitted, actionHash: prepared.actionHash };
+    }
+    async submitOwnershipAction(actionName, input, signer, options = {}) {
+        const controller = await signer.getController();
+        const signerLane = toHex(controller.public).toLowerCase();
+        const previous = this.ownershipTails.get(signerLane) ?? Promise.resolve();
+        let release;
+        const lane = new Promise((resolve) => { release = resolve; });
+        this.ownershipTails.set(signerLane, lane);
+        await previous;
+        try {
+            await this.validateDeployment();
+            const action = actionByName(this.deployment.abi, actionName);
+            if (!isOwnershipAuth(action.auth))
+                throw new Error("submitOwnershipAction requires an ownership-authenticated action");
+            const payload = encodeActionPayload(this.deployment.abi, actionName, input);
+            const selector = actionSelector(actionName);
+            if (!sameHex(toHex(selector), action.selector))
+                throw new Error("deployment ABI selector does not match the canonical selector");
+            const context = await this.rpc.finalizedContext();
+            const effectiveOwner = options.actAs ?? controller;
+            const root = await this.managedStateRoot(context);
+            const nonceBytes = await this.readManagedValue(root, ownershipNonceKey(effectiveOwner));
+            const chainNonce = nonceBytes === null ? 0n : decodeValue("u64", nonceBytes);
+            if (typeof chainNonce !== "bigint")
+                throw new Error("ownership nonce storage is not u64");
+            const unsigned = {
+                version: 2,
+                networkDomain: parseHex(this.deployment.networkDomain, 32),
+                serviceKey: parseHex(this.deployment.serviceKey, 32),
+                actionSelector: selector,
+                controller,
+                actAs: options.actAs ?? null,
+                nonce: chainNonce,
+                validUntil: BigInt(context.slot) + (options.ttl ?? 64n),
+                payloadHash: blake2(payload),
+                payload,
+            };
+            const message = signingMessageV2(unsigned);
+            const authorizationProof = await signer.signJamScriptAction({ ...unsigned, message });
+            if (authorizationProof.length === 0 || authorizationProof.length > 65536)
+                throw new Error("invalid Ownership authorization proof");
+            const signed = encodeSignedActionV2({ ...unsigned, authorizationProof });
+            const actionHash = toHex(blake2(signed));
+            const submitted = await this.rpc.submitTransaction({
+                serviceId: this.deployment.serviceId,
+                serviceCodeHash: this.deployment.codeHash,
+                payloadBase64: toBase64(signed),
+                extrinsicsBase64: (options.extrinsics ?? []).map(toBase64),
+            });
+            this.actionHashes.set(submitted.transactionId.toLowerCase(), actionHash);
+            return { ...submitted, actionHash };
+        }
+        finally {
+            release();
+            if (this.ownershipTails.get(signerLane) === lane)
+                this.ownershipTails.delete(signerLane);
+        }
+    }
+    async reserveWalletNonce(publicKey) {
+        const signerKey = toHex(publicKey).toLowerCase();
+        const previous = this.nonceTails.get(signerKey) ?? Promise.resolve();
+        let release;
+        const lane = new Promise((resolve) => { release = resolve; });
+        this.nonceTails.set(signerKey, lane);
+        await previous;
+        try {
+            const context = await this.rpc.finalizedContext();
+            const localNonce = this.nextNonces.get(signerKey);
+            const chainNonce = localNonce === undefined
+                ? await this.readNonce(publicKey, context)
+                : localNonce;
+            const nonce = localNonce === undefined || localNonce < chainNonce ? chainNonce : localNonce;
+            this.nextNonces.set(signerKey, nonce + 1n);
+            return { context, nonce };
+        }
+        finally {
+            release();
+            if (this.nonceTails.get(signerKey) === lane)
+                this.nonceTails.delete(signerKey);
+        }
+    }
+    async prepareAction(actionName, input, signer, options) {
+        await this.validateDeployment();
+        const action = actionByName(this.deployment.abi, actionName);
+        if (action.auth !== "wallet")
+            throw new Error("submitAction requires a wallet-authenticated action");
+        if (signer.publicKey.length !== 32)
+            throw new Error("sr25519 public key must be 32 bytes");
+        const payload = encodeActionPayload(this.deployment.abi, actionName, input);
+        const selector = actionSelector(actionName);
+        if (!sameHex(toHex(selector), action.selector)) {
+            throw new Error("deployment ABI selector does not match the canonical selector");
+        }
+        const { context: initialContext, nonce } = await this.reserveWalletNonce(signer.publicKey);
+        const ttl = options.ttl ?? 64n;
+        const validUntil = BigInt(initialContext.slot) + ttl;
+        const unsigned = {
+            version: 1,
+            networkDomain: parseHex(this.deployment.networkDomain, 32),
+            serviceKey: parseHex(this.deployment.serviceKey, 32),
+            actionSelector: selector,
+            signerScheme: 0,
+            publicKey: signer.publicKey,
+            nonce,
+            validUntil,
+            payloadHash: blake2(payload),
+            payload,
+        };
+        const signature = await signer.signRaw(signingDigestV1(unsigned));
+        if (signature.length !== 64)
+            throw new Error("sr25519 signRaw must return a 64-byte signature");
+        const signed = encodeSignedActionV1({ ...unsigned, signature });
+        const actionHash = toHex(blake2(signed));
+        const requestBase = {
+            serviceId: this.deployment.serviceId,
+            serviceCodeHash: this.deployment.codeHash,
+            payloadBase64: toBase64(signed),
+            extrinsicsBase64: (options.extrinsics ?? []).map(toBase64),
+        };
+        return { request: requestBase, actionHash, nonce };
+    }
+    async queryLatest(queryName, key) {
+        const query = queryByName(this.deployment.abi, queryName);
+        const state = stateByName(this.deployment.abi, query.state);
+        const keyBytes = isUnitType(state.keyType)
+            ? new Uint8Array()
+            : encodeValue(state.keyType, key === undefined ? null : key);
+        if (JSON.stringify(query.keyType) !== JSON.stringify(state.keyType))
+            throw new Error("query key type does not match state key type");
+        const context = await this.rpc.finalizedContext();
+        const root = await this.managedStateRoot(context);
+        const valueBytes = await this.readManagedValue(root, stateKey(state.schema, keyBytes));
+        return {
+            value: valueBytes === null
+                ? null
+                : decodeValue(query.output.type, valueBytes),
+            context,
+            stateRoot: toHex(root),
+        };
+    }
+    async query(queryName, key) {
+        return this.queryLatest(queryName, key);
+    }
+    async managedStateRoot(context) {
+        const encoded = await this.rpc.serviceStorageAt(context.blockHash, this.deployment.serviceId, toHex(MANAGED_STATE_COMMITMENT_KEY_V1));
+        if (encoded === null)
+            return parseHex(EMPTY_STATE_ROOT_V1);
+        const commitment = decodeStateValue(parseHex(encoded));
+        if (commitment.length !== 34 || commitment[0] !== 1 || commitment[1] !== 1) {
+            throw new Error("invalid ManagedStateCommitmentV1");
+        }
+        return commitment.slice(2);
+    }
+    async readManagedValue(root, key) {
+        const response = await this.stateProvider.get({
+            serviceId: this.deployment.serviceId,
+            serviceKey: this.deployment.serviceKey,
+            stateRoot: toHex(root),
+            key,
+        });
+        if (response.serviceId !== this.deployment.serviceId
+            || response.stateRoot.toLowerCase() !== toHex(root).toLowerCase()
+            || !sameBytes(response.key, key)) {
+            throw new Error("managed-state provider response does not match the requested query");
+        }
+        if (this.verifyProofs)
+            return verifyManagedStateProof(root, key, response.value, response.proof);
+        return response.value;
+    }
+    workStatus(packageHash) {
+        return this.rpc.workStatus(packageHash, this.deployment.serviceId);
+    }
+    transactionStatus(transactionId) {
+        return this.rpc.transactionStatus(transactionId);
+    }
+    async waitForTransaction(transactionId, options = {}) {
+        const intervalMs = options.intervalMs ?? 1_000;
+        const deadline = Date.now() + (options.timeoutMs ?? 120_000);
+        for (;;) {
+            try {
+                const status = await this.transactionStatus(transactionId);
+                if (status.status === "imported" || status.status === "failed")
+                    return status;
+            }
+            catch (error) {
+                if (!(error instanceof RpcError) || error.code !== -32013)
+                    throw error;
+            }
+            if (Date.now() >= deadline)
+                throw new Error("timed out waiting for transaction");
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    async waitForWork(packageHash, options = {}) {
+        const intervalMs = options.intervalMs ?? 1_000;
+        const deadline = Date.now() + (options.timeoutMs ?? 120_000);
+        for (;;) {
+            try {
+                const status = await this.workStatus(packageHash);
+                if (status.status === "imported" || status.status === "failed")
+                    return status;
+            }
+            catch (error) {
+                if (!(error instanceof RpcError)
+                    || (error.code !== -32013 && error.message !== "work not found"))
+                    throw error;
+            }
+            if (Date.now() >= deadline)
+                throw new Error("timed out waiting for finalized Work");
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    async waitForAction(transactionId, optionsOrActionHash = {}, legacyOptions = {}) {
+        const options = typeof optionsOrActionHash === "string" ? legacyOptions : optionsOrActionHash;
+        const transaction = await this.waitForTransaction(transactionId, options);
+        if (transaction.status === "failed") {
+            throw new RpcError("transaction failed before an action receipt was produced", -32040, transaction);
+        }
+        const expected = this.actionHashes.get(transactionId.toLowerCase())
+            ?? (typeof optionsOrActionHash === "string" ? optionsOrActionHash : undefined);
+        if (!expected)
+            throw new Error("action hash is unavailable for this client instance");
+        const actionIndex = transaction.actionIndex;
+        const receipt = actionIndex === null ? undefined : transaction.actionReceipts?.[actionIndex];
+        if (!receipt) {
+            throw new Error("canonical action receipt is missing for the transaction action index");
+        }
+        if (!sameHex(receipt.actionHash, expected)) {
+            throw new Error("transaction action index resolved to a different action hash");
+        }
+        return {
+            ...transaction,
+            status: receipt.status,
+            transactionStatus: transaction.status,
+            actionHash: receipt.actionHash,
+            errorCode: receipt.errorCode,
+            actionReceipt: receipt,
+        };
+    }
+}
+function isUnitType(type) {
+    return typeof type === "string" ? type === "unit" : type.kind === "unit";
+}
+function isOwnershipAuth(auth) {
+    return typeof auth === "object" && auth.kind === "ownership" && auth.version === 1;
+}
+function blake2(bytes) {
+    return blake2AsU8a(bytes, 256);
+}
+function toBase64(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function fromBase64(value) {
+    const binary = atob(value);
+    const output = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1)
+        output[index] = binary.charCodeAt(index);
+    return output;
+}
+function sameBytes(left, right) {
+    return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function sameHex(left, right) {
+    return left.toLowerCase().replace(/^0x/, "") === right.toLowerCase().replace(/^0x/, "");
+}

package/dist/codec.d.ts

@@ -0,0 +1,8 @@
+import type { AbiTypeRef, JamScriptAbi } from "./abi.js";
+export type CodecValue = null | undefined | bigint | number | boolean | string | Uint8Array | CodecValue[] | {
+    [key: string]: CodecValue;
+};
+export declare function encodeValue(type: AbiTypeRef, value: CodecValue): Uint8Array;
+export declare function decodeValue(type: AbiTypeRef, bytes: Uint8Array): CodecValue;
+export declare function encodeActionPayload(abi: JamScriptAbi, actionName: string, values: Record<string, CodecValue>): Uint8Array;
+export declare function decodeStateValue(encoded: Uint8Array): Uint8Array;

package/dist/codec.js

@@ -0,0 +1,314 @@
+import { decodeOwnership, encodeOwnership } from "./crypto.js";
+class Writer {
+    chunks = [];
+    push(bytes) { this.chunks.push(bytes); }
+    finish() { const size = this.chunks.reduce((sum, chunk) => sum + chunk.length, 0); const output = new Uint8Array(size); let offset = 0; for (const chunk of this.chunks) {
+        output.set(chunk, offset);
+        offset += chunk.length;
+    } return output; }
+}
+class Reader {
+    bytes;
+    offset = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    take(length) { const end = this.offset + length; if (!Number.isSafeInteger(end) || end > this.bytes.length)
+        throw new Error("truncated JAM value"); const result = this.bytes.slice(this.offset, end); this.offset = end; return result; }
+    u8() { return this.take(1)[0]; }
+    natural() { const first = this.u8(); if (first < 0x80)
+        return BigInt(first); const extra = first === 0xff ? 8 : Math.clz32((~first) & 0xff) - 24; if (extra === 8)
+        return new DataView(this.take(8).buffer).getBigUint64(0, true); let result = 0n; for (let i = 0; i < extra; i += 1)
+        result |= BigInt(this.u8()) << BigInt(i * 8); return result | BigInt(first & (0x7f >> extra)) << BigInt(extra * 8); }
+    remaining() { return this.bytes.length - this.offset; }
+}
+function compact(value) { if (value < 0n)
+    throw new Error("length cannot be negative"); if (value < 128n)
+    return Uint8Array.of(Number(value)); if (value < (1n << 56n)) {
+    let extra = 0;
+    let threshold = 128n;
+    while (value >= threshold) {
+        extra += 1;
+        threshold <<= 7n;
+    }
+    const output = new Uint8Array(extra + 1);
+    output[0] = (256 - (1 << (8 - extra))) | Number(value >> BigInt(extra * 8));
+    let left = value;
+    for (let i = 0; i < extra; i += 1) {
+        output[i + 1] = Number(left & 0xffn);
+        left >>= 8n;
+    }
+    return output;
+} const output = new Uint8Array(9); output[0] = 0xff; let left = value; for (let i = 0; i < 8; i += 1) {
+    output[i + 1] = Number(left & 0xffn);
+    left >>= 8n;
+} if (left !== 0n)
+    throw new Error("natural is out of range"); return output; }
+function asBytes(value) { if (!(value instanceof Uint8Array))
+    throw new Error("expected Uint8Array"); return value; }
+function integer(value, min, max, type) { const result = typeof value === "bigint" ? value : typeof value === "number" && Number.isSafeInteger(value) ? BigInt(value) : null; if (result === null)
+    throw new Error(type + " must be a bigint or safe integer"); if (result < min || result > max)
+    throw new Error(type + " is out of range"); return result; }
+function le(value, width) { const result = new Uint8Array(width); let left = BigInt.asUintN(width * 8, value); for (let i = 0; i < width; i += 1) {
+    result[i] = Number(left & 0xffn);
+    left >>= 8n;
+} return result; }
+function readLe(reader, width, signed) { const data = reader.take(width); let result = 0n; for (let i = width - 1; i >= 0; i -= 1)
+    result = (result << 8n) | BigInt(data[i]); return signed ? BigInt.asIntN(width * 8, result) : result; }
+function descriptor(type) {
+    if (typeof type !== "string")
+        return type;
+    const bounded = /^(Bytes|bytes|String|string)<([0-9]+)>$/.exec(type);
+    if (bounded)
+        return { kind: bounded[1].toLowerCase() === "bytes" ? "bytes" : "string", max: Number(bounded[2]) };
+    const fixed = /^(FixedBytes|fixedBytes)<([0-9]+)>$/.exec(type);
+    if (fixed)
+        return { kind: "fixedBytes", len: Number(fixed[2]) };
+    if (["unit", "bool", "u8", "u16", "u32", "u64", "u128", "i8", "i16", "i32", "i64", "i128", "address", "ownership"].includes(type))
+        return { kind: type };
+    throw new Error("unsupported ABI type: " + type);
+}
+function encode(type, value, writer) {
+    const ty = descriptor(type);
+    switch (ty.kind) {
+        case "unit": return;
+        case "bool":
+            if (typeof value !== "boolean")
+                throw new Error("bool must be a boolean");
+            writer.push(Uint8Array.of(value ? 1 : 0));
+            return;
+        case "u8":
+            writer.push(Uint8Array.of(Number(integer(value, 0n, 0xffn, "u8"))));
+            return;
+        case "u16":
+            writer.push(le(integer(value, 0n, 0xffffn, "u16"), 2));
+            return;
+        case "u32":
+            writer.push(le(integer(value, 0n, 0xffffffffn, "u32"), 4));
+            return;
+        case "u64":
+            writer.push(le(integer(value, 0n, 0xffffffffffffffffn, "u64"), 8));
+            return;
+        case "u128":
+            writer.push(le(integer(value, 0n, (1n << 128n) - 1n, "u128"), 16));
+            return;
+        case "i8":
+            writer.push(le(integer(value, -128n, 127n, "i8"), 1));
+            return;
+        case "i16":
+            writer.push(le(integer(value, -32768n, 32767n, "i16"), 2));
+            return;
+        case "i32":
+            writer.push(le(integer(value, -2147483648n, 2147483647n, "i32"), 4));
+            return;
+        case "i64":
+            writer.push(le(integer(value, -(1n << 63n), (1n << 63n) - 1n, "i64"), 8));
+            return;
+        case "i128":
+            writer.push(le(integer(value, -(1n << 127n), (1n << 127n) - 1n, "i128"), 16));
+            return;
+        case "address": {
+            const data = asBytes(value);
+            if (data.length !== 32)
+                throw new Error("address must be 32 bytes");
+            writer.push(data);
+            return;
+        }
+        case "ownership": {
+            if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Uint8Array)
+                throw new Error("ownership must be an Ownership object");
+            writer.push(encodeOwnership(value));
+            return;
+        }
+        case "fixedBytes": {
+            const data = asBytes(value);
+            if (data.length !== ty.len)
+                throw new Error(`fixedBytes length must be ${ty.len}`);
+            writer.push(data);
+            return;
+        }
+        case "bytes": {
+            const data = asBytes(value);
+            if (data.length > ty.max)
+                throw new Error("bytes value exceeds its bound");
+            writer.push(compact(BigInt(data.length)));
+            writer.push(data);
+            return;
+        }
+        case "string": {
+            if (typeof value !== "string")
+                throw new Error("string must be a string");
+            const data = new TextEncoder().encode(value);
+            if (data.length > ty.max)
+                throw new Error("string value exceeds its UTF-8 byte bound");
+            writer.push(compact(BigInt(data.length)));
+            writer.push(data);
+            return;
+        }
+        case "fixedArray":
+            if (!Array.isArray(value) || value.length !== ty.len)
+                throw new Error("fixedArray length mismatch");
+            value.forEach(item => encode(ty.item, item, writer));
+            return;
+        case "array":
+            if (!Array.isArray(value) || value.length > ty.max)
+                throw new Error("array value exceeds its bound");
+            writer.push(compact(BigInt(value.length)));
+            value.forEach(item => encode(ty.item, item, writer));
+            return;
+        case "option":
+            if (value === null || value === undefined)
+                writer.push(Uint8Array.of(0));
+            else {
+                writer.push(Uint8Array.of(1));
+                encode(ty.item, value, writer);
+            }
+            return;
+        case "tuple":
+            if (!Array.isArray(value) || value.length !== ty.items.length)
+                throw new Error("tuple length mismatch");
+            ty.items.forEach((item, i) => encode(item, value[i], writer));
+            return;
+        case "record":
+            if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Uint8Array)
+                throw new Error("record must be an object");
+            ty.fields.forEach(field => { if (!(field.name in value))
+                throw new Error("missing record field: " + field.name); encode(field.type, value[field.name], writer); });
+            return;
+        case "enum": {
+            if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Uint8Array)
+                throw new Error("enum must contain index and value");
+            const enumeration = value;
+            if (typeof enumeration.index !== "number" || enumeration.value === undefined)
+                throw new Error("enum must contain index and value");
+            const variant = ty.variants.find(candidate => candidate.index === enumeration.index);
+            if (!variant)
+                throw new Error("invalid enum variant");
+            writer.push(Uint8Array.of(enumeration.index));
+            encode(variant.type, enumeration.value, writer);
+            return;
+        }
+        case "result": {
+            if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Uint8Array)
+                throw new Error("result must be an object");
+            const result = value;
+            const ok = "ok" in result;
+            writer.push(Uint8Array.of(ok ? 0 : 1));
+            encode(ok ? ty.ok : ty.err, ok ? result.ok : result.err, writer);
+            return;
+        }
+        default: throw new Error("unsupported ABI type");
+    }
+}
+function decode(reader, type) {
+    const ty = descriptor(type);
+    switch (ty.kind) {
+        case "unit": return undefined;
+        case "bool": {
+            const value = reader.u8();
+            if (value > 1)
+                throw new Error("invalid bool value");
+            return value === 1;
+        }
+        case "u8": return Number(readLe(reader, 1, false));
+        case "u16": return Number(readLe(reader, 2, false));
+        case "u32": return Number(readLe(reader, 4, false));
+        case "u64": return readLe(reader, 8, false);
+        case "u128": return readLe(reader, 16, false);
+        case "i8": return Number(readLe(reader, 1, true));
+        case "i16": return Number(readLe(reader, 2, true));
+        case "i32": return Number(readLe(reader, 4, true));
+        case "i64": return readLe(reader, 8, true);
+        case "i128": return readLe(reader, 16, true);
+        case "address": return reader.take(32);
+        case "ownership": {
+            const start = reader.take(4);
+            const length = start[2] | (start[3] << 8);
+            return decodeOwnership(new Uint8Array([...start, ...reader.take(length)]));
+        }
+        case "fixedBytes": return reader.take(ty.len);
+        case "bytes": {
+            const length = reader.natural();
+            if (length > BigInt(ty.max))
+                throw new Error("bytes value exceeds its bound");
+            return reader.take(Number(length));
+        }
+        case "string": {
+            const length = reader.natural();
+            if (length > BigInt(ty.max))
+                throw new Error("string value exceeds its UTF-8 byte bound");
+            return new TextDecoder("utf-8", { fatal: true }).decode(reader.take(Number(length)));
+        }
+        case "fixedArray": return Array.from({ length: ty.len }, () => decode(reader, ty.item));
+        case "array": {
+            const length = reader.natural();
+            if (length > BigInt(ty.max))
+                throw new Error("array value exceeds its bound");
+            return Array.from({ length: Number(length) }, () => decode(reader, ty.item));
+        }
+        case "option": {
+            const tag = reader.u8();
+            if (tag === 0)
+                return null;
+            if (tag !== 1)
+                throw new Error("invalid option tag");
+            return decode(reader, ty.item);
+        }
+        case "tuple": return ty.items.map(item => decode(reader, item));
+        case "record": return Object.fromEntries(ty.fields.map(field => [field.name, decode(reader, field.type)]));
+        case "enum": {
+            const index = reader.u8();
+            const variant = ty.variants.find(candidate => candidate.index === index);
+            if (!variant)
+                throw new Error("invalid enum variant");
+            return { index, value: decode(reader, variant.type) };
+        }
+        case "result": {
+            const tag = reader.u8();
+            if (tag === 0)
+                return { ok: decode(reader, ty.ok) };
+            if (tag === 1)
+                return { err: decode(reader, ty.err) };
+            throw new Error("invalid result tag");
+        }
+        default: throw new Error("unsupported ABI type");
+    }
+}
+export function encodeValue(type, value) { const writer = new Writer(); encode(type, value, writer); return writer.finish(); }
+export function decodeValue(type, bytes) { const reader = new Reader(bytes); const result = decode(reader, type); if (reader.remaining() !== 0)
+    throw new Error("trailing bytes in ABI value"); return result; }
+export function encodeActionPayload(abi, actionName, values) { const action = abi.actions.find(candidate => candidate.name === actionName); if (!action)
+    throw new Error("unknown JamScript action: " + actionName); const writer = new Writer(); for (const field of action.input) {
+    if (!(field.name in values))
+        throw new Error("missing action field: " + field.name);
+    encode(field.type, values[field.name], writer);
+} return writer.finish(); }
+export function decodeStateValue(encoded) {
+    if (encoded.length === 0)
+        throw new Error("empty StateValue");
+    const first = encoded[0];
+    let length;
+    let offset;
+    switch (first & 3) {
+        case 0:
+            length = first >>> 2;
+            offset = 1;
+            break;
+        case 1:
+            if (encoded.length < 2)
+                throw new Error("truncated StateValue length");
+            length = ((encoded[0] | (encoded[1] << 8)) >>> 2);
+            offset = 2;
+            break;
+        case 2:
+            if (encoded.length < 4)
+                throw new Error("truncated StateValue length");
+            length = ((encoded[0] | (encoded[1] << 8) | (encoded[2] << 16) | (encoded[3] << 24)) >>> 2);
+            offset = 4;
+            break;
+        default: throw new Error("StateValue is too large for browser client");
+    }
+    if (offset + length !== encoded.length)
+        throw new Error("invalid StateValue length");
+    return encoded.slice(offset);
+}