@jamscript/client 0.1.0-rc.1

package/dist/crypto.d.ts

@@ -0,0 +1,65 @@
+export declare const ACTION_DOMAIN_V1: Uint8Array<ArrayBuffer>;
+export declare const APPLICATION_KEY_CLASS_V1 = 1;
+export declare const RUNTIME_KEY_CLASS_V1 = 0;
+export declare const WALLET_AUTH_MODULE_V1 = 1;
+export declare const MANAGED_STATE_COMMITMENT_KEY_V1: Uint8Array<ArrayBuffer>;
+export declare const MAX_ACTION_PAYLOAD_BYTES = 1048576;
+export declare const OWNERSHIP_VERSION_V1 = 1;
+export declare const MAX_OWNERSHIP_BYTES = 4096;
+export declare const OWNERSHIP_KEY_DOMAIN_V1: Uint8Array<ArrayBuffer>;
+export declare const OWNERSHIP_KIND: {
+    readonly ED25519_KEY: 0;
+    readonly SR25519_KEY: 1;
+    readonly SECP256K1_KEY: 2;
+    readonly SECP256K1_KECCAK20: 3;
+    readonly MULTICRYPTO_ACCOUNT32: 4;
+};
+export type OwnershipKind = typeof OWNERSHIP_KIND[keyof typeof OWNERSHIP_KIND];
+export type Ownership = {
+    version: 1;
+    kind: OwnershipKind;
+    public: Uint8Array;
+};
+export type ServiceKeyV1 = Uint8Array;
+export type SignedActionV1 = {
+    version: 1;
+    networkDomain: Uint8Array;
+    serviceKey: ServiceKeyV1;
+    actionSelector: Uint8Array;
+    signerScheme: 0;
+    publicKey: Uint8Array;
+    nonce: bigint;
+    validUntil: bigint;
+    payloadHash: Uint8Array;
+    signature: Uint8Array;
+    payload: Uint8Array;
+};
+export type SignedActionV2 = {
+    version: 2;
+    networkDomain: Uint8Array;
+    serviceKey: ServiceKeyV1;
+    actionSelector: Uint8Array;
+    controller: Ownership;
+    actAs: Ownership | null;
+    nonce: bigint;
+    validUntil: bigint;
+    payloadHash: Uint8Array;
+    authorizationProof: Uint8Array;
+    payload: Uint8Array;
+};
+export declare function encodeOwnership(ownership: Ownership): Uint8Array;
+export declare function decodeOwnership(bytes: Uint8Array): Ownership;
+export declare function ownershipKey(ownership: Ownership): Uint8Array;
+export declare function ownershipNonceKey(ownership: Ownership): Uint8Array;
+export declare function parseHex(value: string, expectedBytes?: number): Uint8Array;
+export declare function toHex(value: Uint8Array): string;
+export declare function actionSelector(name: string): Uint8Array;
+export declare function stateKey(schema: Uint8Array | string, key: Uint8Array): Uint8Array;
+export declare function nonceKey(publicKey: Uint8Array): Uint8Array;
+export declare function signingDigestV1(action: Omit<SignedActionV1, "signature">): Uint8Array;
+export declare function encodeSignedActionV1(action: SignedActionV1): Uint8Array;
+export declare function decodeSignedActionV1(bytes: Uint8Array): SignedActionV1;
+export declare function actionCommitmentV2(action: Omit<SignedActionV2, "authorizationProof">): Uint8Array;
+export declare function signingMessageV2(action: Omit<SignedActionV2, "authorizationProof">): Uint8Array;
+export declare function encodeSignedActionV2(action: SignedActionV2): Uint8Array;
+export declare function decodeSignedActionV2(bytes: Uint8Array): SignedActionV2;

package/dist/crypto.js

@@ -0,0 +1,233 @@
+import { hexToU8a, u8aToHex } from "@polkadot/util";
+import { blake2AsU8a } from "@polkadot/util-crypto";
+export const ACTION_DOMAIN_V1 = new TextEncoder().encode("JAMSCRIPT_ACTION_V1");
+export const APPLICATION_KEY_CLASS_V1 = 0x01;
+export const RUNTIME_KEY_CLASS_V1 = 0x00;
+export const WALLET_AUTH_MODULE_V1 = 0x01;
+export const MANAGED_STATE_COMMITMENT_KEY_V1 = new TextEncoder().encode(":jam-service-runtime:managed-state:v1");
+export const MAX_ACTION_PAYLOAD_BYTES = 1_048_576;
+export const OWNERSHIP_VERSION_V1 = 1;
+export const MAX_OWNERSHIP_BYTES = 4096;
+export const OWNERSHIP_KEY_DOMAIN_V1 = new TextEncoder().encode("OWNERSHIP_ABSTRACTION_KEY_V1");
+export const OWNERSHIP_KIND = {
+    ED25519_KEY: 0,
+    SR25519_KEY: 1,
+    SECP256K1_KEY: 2,
+    SECP256K1_KECCAK20: 3,
+    MULTICRYPTO_ACCOUNT32: 4,
+};
+function concat(...parts) {
+    const output = new Uint8Array(parts.reduce((size, part) => size + part.length, 0));
+    let offset = 0;
+    for (const part of parts) {
+        output.set(part, offset);
+        offset += part.length;
+    }
+    return output;
+}
+function u32(value) {
+    const output = new Uint8Array(4);
+    new DataView(output.buffer).setUint32(0, value, true);
+    return output;
+}
+function u16(value) {
+    return Uint8Array.of(value & 0xff, (value >>> 8) & 0xff);
+}
+function u64(value) {
+    const output = new Uint8Array(8);
+    new DataView(output.buffer).setBigUint64(0, value, true);
+    return output;
+}
+function byte(value) {
+    return Uint8Array.of(value);
+}
+function ownershipPublicLength(kind) {
+    if (kind === OWNERSHIP_KIND.SECP256K1_KEY)
+        return 33;
+    if (kind === OWNERSHIP_KIND.SECP256K1_KECCAK20)
+        return 20;
+    return 32;
+}
+export function encodeOwnership(ownership) {
+    if (ownership.version !== 1 || ownership.public.length !== ownershipPublicLength(ownership.kind)) {
+        throw new Error("invalid Ownership public value");
+    }
+    if (ownership.kind === OWNERSHIP_KIND.SECP256K1_KEY && ownership.public[0] !== 2 && ownership.public[0] !== 3) {
+        throw new Error("invalid compressed secp256k1 public key");
+    }
+    if (ownership.public.length > 0xffff || ownership.public.length + 4 > MAX_OWNERSHIP_BYTES)
+        throw new Error("Ownership is too large");
+    return concat(byte(1), byte(ownership.kind), Uint8Array.of(ownership.public.length & 0xff, ownership.public.length >>> 8), ownership.public);
+}
+export function decodeOwnership(bytes) {
+    if (bytes.length < 4 || bytes.length > MAX_OWNERSHIP_BYTES || bytes[0] !== 1)
+        throw new Error("invalid Ownership encoding");
+    const kind = bytes[1];
+    if (kind < 0 || kind > 4)
+        throw new Error("unsupported Ownership kind");
+    const length = bytes[2] | (bytes[3] << 8);
+    if (length !== ownershipPublicLength(kind) || bytes.length !== 4 + length)
+        throw new Error("invalid Ownership length");
+    if (kind === OWNERSHIP_KIND.SECP256K1_KEY && bytes[4] !== 2 && bytes[4] !== 3) {
+        throw new Error("invalid compressed secp256k1 public key");
+    }
+    return { version: 1, kind, public: bytes.slice(4) };
+}
+export function ownershipKey(ownership) {
+    return blake2AsU8a(concat(OWNERSHIP_KEY_DOMAIN_V1, encodeOwnership(ownership)), 256);
+}
+export function ownershipNonceKey(ownership) {
+    return concat(byte(RUNTIME_KEY_CLASS_V1), byte(WALLET_AUTH_MODULE_V1), new TextEncoder().encode("__jamscript/runtime/ownership/nonces/"), ownershipKey(ownership));
+}
+export function parseHex(value, expectedBytes) {
+    const output = hexToU8a(value);
+    if (expectedBytes !== undefined && output.length !== expectedBytes) {
+        throw new Error("expected " + expectedBytes + " bytes, got " + output.length);
+    }
+    return output;
+}
+export function toHex(value) {
+    return u8aToHex(value);
+}
+export function actionSelector(name) {
+    return blake2AsU8a(concat(new TextEncoder().encode("jamscript/action/v1:"), new TextEncoder().encode(name)), 256).slice(0, 8);
+}
+export function stateKey(schema, key) {
+    const schemaBytes = typeof schema === "string" ? new TextEncoder().encode(schema) : schema;
+    if (schemaBytes.length > 0xffff)
+        throw new Error("managed state namespace is too large");
+    return concat(byte(APPLICATION_KEY_CLASS_V1), Uint8Array.of(schemaBytes.length & 0xff, schemaBytes.length >>> 8), schemaBytes, key);
+}
+export function nonceKey(publicKey) {
+    if (publicKey.length !== 32)
+        throw new Error("wallet account must be 32 bytes");
+    return concat(byte(RUNTIME_KEY_CLASS_V1), byte(WALLET_AUTH_MODULE_V1), publicKey);
+}
+export function signingDigestV1(action) {
+    if (action.networkDomain.length !== 32 || action.serviceKey.length !== 32 || action.actionSelector.length !== 8) {
+        throw new Error("invalid SignedActionV1 fixed-width field");
+    }
+    return blake2AsU8a(concat(ACTION_DOMAIN_V1, byte(action.version), action.networkDomain, action.serviceKey, action.actionSelector, byte(action.signerScheme), u64(action.nonce), u64(action.validUntil), action.payloadHash), 256);
+}
+export function encodeSignedActionV1(action) {
+    if (action.networkDomain.length !== 32 || action.serviceKey.length !== 32 || action.actionSelector.length !== 8) {
+        throw new Error("invalid SignedActionV1 fixed-width field");
+    }
+    if (action.publicKey.length > 32 || action.signature.length > 64) {
+        throw new Error("SignedActionV1 variable-width field is too large");
+    }
+    if (action.payload.length > MAX_ACTION_PAYLOAD_BYTES)
+        throw new Error("SignedActionV1 payload is too large");
+    return concat(byte(action.version), action.networkDomain, action.serviceKey, action.actionSelector, byte(action.signerScheme), byte(action.publicKey.length), action.publicKey, u64(action.nonce), u64(action.validUntil), action.payloadHash, byte(action.signature.length), action.signature, u32(action.payload.length), action.payload);
+}
+export function decodeSignedActionV1(bytes) {
+    let offset = 0;
+    const take = (length) => {
+        const end = offset + length;
+        if (end > bytes.length)
+            throw new Error("truncated SignedActionV1");
+        const value = bytes.slice(offset, end);
+        offset = end;
+        return value;
+    };
+    const readU8 = () => take(1)[0];
+    const readU32 = () => new DataView(take(4).buffer).getUint32(0, true);
+    const readU64 = () => new DataView(take(8).buffer).getBigUint64(0, true);
+    const version = readU8();
+    const networkDomain = take(32);
+    const serviceKey = take(32);
+    const actionSelector = take(8);
+    const signerScheme = readU8();
+    const publicKey = take(readU8());
+    const nonce = readU64();
+    const validUntil = readU64();
+    const payloadHash = take(32);
+    const signature = take(readU8());
+    const payload = take(readU32());
+    if (offset !== bytes.length)
+        throw new Error("trailing SignedActionV1 bytes");
+    if (version !== 1 || signerScheme !== 0 || publicKey.length !== 32 || signature.length !== 64 || payload.length > MAX_ACTION_PAYLOAD_BYTES) {
+        throw new Error("unsupported SignedActionV1");
+    }
+    if (toHex(blake2AsU8a(payload, 256)) !== toHex(payloadHash)) {
+        throw new Error("SignedActionV1 payload hash mismatch");
+    }
+    return { version: 1, networkDomain, serviceKey, actionSelector, signerScheme: 0, publicKey, nonce, validUntil, payloadHash, signature, payload };
+}
+export function actionCommitmentV2(action) {
+    if (action.networkDomain.length !== 32 || action.serviceKey.length !== 32 || action.actionSelector.length !== 8)
+        throw new Error("invalid SignedActionV2 fixed-width field");
+    const parts = [
+        new TextEncoder().encode("JAMSCRIPT_ACTION_V2"),
+        action.networkDomain,
+        action.serviceKey,
+        action.actionSelector,
+        encodeOwnership(action.controller),
+        byte(action.actAs === null ? 0 : 1),
+        ...(action.actAs === null ? [] : [encodeOwnership(action.actAs)]),
+        u64(action.nonce),
+        u64(action.validUntil),
+        action.payloadHash,
+    ];
+    return blake2AsU8a(concat(...parts), 256);
+}
+export function signingMessageV2(action) {
+    const commitment = actionCommitmentV2(action);
+    const encoded = base64Url(commitment);
+    return new TextEncoder().encode("JAMSCRIPT_ACTION_V2:" + encoded);
+}
+function base64Url(bytes) {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let output = "";
+    for (let index = 0; index < bytes.length; index += 3) {
+        const a = bytes[index];
+        const b = index + 1 < bytes.length ? bytes[index + 1] : 0;
+        const c = index + 2 < bytes.length ? bytes[index + 2] : 0;
+        output += alphabet[a >>> 2];
+        output += alphabet[((a & 3) << 4) | (b >>> 4)];
+        output += index + 1 < bytes.length ? alphabet[((b & 15) << 2) | (c >>> 6)] : "=";
+        output += index + 2 < bytes.length ? alphabet[c & 63] : "=";
+    }
+    return output.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+export function encodeSignedActionV2(action) {
+    if (action.version !== 2 || action.networkDomain.length !== 32 || action.serviceKey.length !== 32 || action.actionSelector.length !== 8)
+        throw new Error("invalid SignedActionV2 fixed-width field");
+    const controller = encodeOwnership(action.controller);
+    const actAs = action.actAs === null ? null : encodeOwnership(action.actAs);
+    if (action.authorizationProof.length > 65536)
+        throw new Error("SignedActionV2 authorization proof is too large");
+    if (action.payload.length > MAX_ACTION_PAYLOAD_BYTES)
+        throw new Error("SignedActionV2 payload is too large");
+    return concat(byte(2), action.networkDomain, action.serviceKey, action.actionSelector, u16(controller.length), controller, byte(actAs === null ? 0 : 1), ...(actAs === null ? [] : [u16(actAs.length), actAs]), u64(action.nonce), u64(action.validUntil), action.payloadHash, u32(action.authorizationProof.length), action.authorizationProof, u32(action.payload.length), action.payload);
+}
+export function decodeSignedActionV2(bytes) {
+    let offset = 0;
+    const take = (length) => { const end = offset + length; if (end > bytes.length)
+        throw new Error("truncated SignedActionV2"); const value = bytes.slice(offset, end); offset = end; return value; };
+    const readU8 = () => take(1)[0];
+    const readU16 = () => { const value = take(2); return value[0] | (value[1] << 8); };
+    const readU32 = () => new DataView(take(4).buffer).getUint32(0, true);
+    const readU64 = () => new DataView(take(8).buffer).getBigUint64(0, true);
+    if (readU8() !== 2)
+        throw new Error("unsupported SignedActionV2");
+    const networkDomain = take(32);
+    const serviceKey = take(32);
+    const actionSelector = take(8);
+    const controller = decodeOwnership(take(readU16()));
+    const flag = readU8();
+    const actAs = flag === 0 ? null : flag === 1 ? decodeOwnership(take(readU16())) : (() => { throw new Error("invalid SignedActionV2 actAs flag"); })();
+    const nonce = readU64();
+    const validUntil = readU64();
+    const payloadHash = take(32);
+    const proofLength = readU32();
+    if (proofLength > 65536)
+        throw new Error("SignedActionV2 authorization proof is too large");
+    const authorizationProof = take(proofLength);
+    const payload = take(readU32());
+    if (offset !== bytes.length)
+        throw new Error("trailing SignedActionV2 bytes");
+    if (toHex(blake2AsU8a(payload, 256)) !== toHex(payloadHash))
+        throw new Error("SignedActionV2 payload hash mismatch");
+    return { version: 2, networkDomain, serviceKey, actionSelector, controller, actAs, nonce, validUntil, payloadHash, authorizationProof, payload };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./abi.js";
+export * from "./client.js";
+export * from "./codec.js";
+export * from "./crypto.js";
+export * from "./proof.js";
+export * from "./rpc.js";
+export * from "./runtime.js";
+export * from "./signer.js";
+export * from "./state-provider.js";
+export * from "./matrix.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./abi.js";
+export * from "./client.js";
+export * from "./codec.js";
+export * from "./crypto.js";
+export * from "./proof.js";
+export * from "./rpc.js";
+export * from "./runtime.js";
+export * from "./signer.js";
+export * from "./state-provider.js";
+export * from "./matrix.js";

package/dist/matrix.d.ts

@@ -0,0 +1,23 @@
+import { type Ownership } from "./crypto.js";
+import type { JamScriptOwnershipSignRequest, OwnershipSigner } from "./signer.js";
+export type MatrixKeyDiscovery = {
+    queryMasterPublicKey(userId: string): Promise<Uint8Array>;
+};
+export declare class MatrixOwnershipResolver {
+    private readonly discovery;
+    constructor(discovery: MatrixKeyDiscovery);
+    resolve(userId: string): Promise<Ownership>;
+}
+export type MatrixDeviceSigning = {
+    sign(message: Uint8Array): Promise<Uint8Array>;
+};
+export declare class MatrixDeviceController implements OwnershipSigner {
+    private readonly signing;
+    private readonly ownership;
+    constructor(deviceEd25519PublicKey: Uint8Array, signing: MatrixDeviceSigning);
+    getController(): Promise<Ownership>;
+    signJamScriptAction(request: JamScriptOwnershipSignRequest): Promise<Uint8Array>;
+}
+export type MatrixControlClaimBootstrapper = {
+    bootstrap(subject: Ownership, controller: Ownership, proof: Uint8Array): Promise<void>;
+};

package/dist/matrix.js

@@ -0,0 +1,31 @@
+import { OWNERSHIP_KIND } from "./crypto.js";
+export class MatrixOwnershipResolver {
+    discovery;
+    constructor(discovery) {
+        this.discovery = discovery;
+    }
+    async resolve(userId) {
+        if (!/^@[^\s:]+:[^\s:]+$/.test(userId))
+            throw new Error("invalid Matrix User ID");
+        const publicKey = await this.discovery.queryMasterPublicKey(userId);
+        if (publicKey.length !== 32)
+            throw new Error("Matrix master key must be 32 bytes");
+        return { version: 1, kind: OWNERSHIP_KIND.ED25519_KEY, public: publicKey };
+    }
+}
+export class MatrixDeviceController {
+    signing;
+    ownership;
+    constructor(deviceEd25519PublicKey, signing) {
+        this.signing = signing;
+        if (deviceEd25519PublicKey.length !== 32)
+            throw new Error("Matrix device key must be 32 bytes");
+        this.ownership = { version: 1, kind: OWNERSHIP_KIND.ED25519_KEY, public: deviceEd25519PublicKey };
+    }
+    async getController() {
+        return this.ownership;
+    }
+    signJamScriptAction(request) {
+        return this.signing.sign(request.message);
+    }
+}

package/dist/proof.d.ts

@@ -0,0 +1 @@
+export declare function verifyManagedStateProof(stateRoot: Uint8Array, key: Uint8Array, claimedValue: Uint8Array | null, proof: Uint8Array[]): Uint8Array | null;

package/dist/proof.js

@@ -0,0 +1,125 @@
+import { trieNodeDec, validateProofs, } from "@polkadot-api/substrate-bindings";
+export function verifyManagedStateProof(stateRoot, key, claimedValue, proof) {
+    if (stateRoot.length !== 32)
+        throw new Error("managed-state root must be 32 bytes");
+    if (proof.length === 0)
+        throw new Error("managed-state proof is empty");
+    const validated = validateProofs(proof);
+    if (validated === null || normalizeHex(validated.rootHash) !== bytesToHex(stateRoot)) {
+        throw new Error("managed-state proof does not match the requested root");
+    }
+    const keyNibbles = bytesToHex(key).slice(2);
+    let offset = 0;
+    let node = requireProofNode(validated.proofs, validated.rootHash);
+    for (;;) {
+        if (node.type === "Raw" || node.type === "Empty" || node.type === "Reserved") {
+            if (node.type === "Empty")
+                return assertClaimedValue(null, claimedValue);
+            throw new Error("invalid managed-state proof node");
+        }
+        if (!keyNibbles.startsWith(node.partialKey, offset)) {
+            return assertClaimedValue(null, claimedValue);
+        }
+        offset += node.partialKey.length;
+        if (node.type === "Leaf" || node.type === "LeafWithHash") {
+            const value = offset === keyNibbles.length
+                ? resolveValue(node.type, node.value, validated.proofs)
+                : null;
+            return assertClaimedValue(value, claimedValue);
+        }
+        if (offset === keyNibbles.length) {
+            const value = node.type === "BranchWithVal"
+                ? hexToBytes(node.value)
+                : node.type === "BranchWithHash"
+                    ? resolveHashedValue(node.value, validated.proofs)
+                    : null;
+            return assertClaimedValue(value, claimedValue);
+        }
+        if (!("children" in node))
+            throw new Error("invalid managed-state branch proof");
+        const child = node.children[keyNibbles[offset]];
+        offset += 1;
+        if (child === undefined)
+            return assertClaimedValue(null, claimedValue);
+        const childBytes = hexToBytes(child);
+        node = childBytes.length === 32
+            ? requireProofNode(validated.proofs, child)
+            : trieNodeDec(childBytes);
+    }
+}
+function resolveValue(type, value, proofs) {
+    return type === "Leaf" ? decodeCompactBytes(hexToBytes(value)) : resolveHashedValue(value, proofs);
+}
+function resolveHashedValue(valueHash, proofs) {
+    const node = requireProofNode(proofs, valueHash);
+    if (node.type !== "Raw")
+        throw new Error("managed-state proof is missing a hashed value");
+    return hexToBytes(node.value);
+}
+function requireProofNode(proofs, hash) {
+    const node = proofs[normalizeHex(hash)];
+    if (node === undefined)
+        throw new Error("managed-state proof is incomplete");
+    return node;
+}
+function assertClaimedValue(verified, claimed) {
+    if (verified === null || claimed === null) {
+        if (verified !== claimed)
+            throw new Error("managed-state value does not match its proof");
+        return verified;
+    }
+    if (verified.length !== claimed.length || verified.some((byte, index) => byte !== claimed[index])) {
+        throw new Error("managed-state value does not match its proof");
+    }
+    return verified;
+}
+function normalizeHex(value) {
+    return "0x" + value.toLowerCase().replace(/^0x/, "");
+}
+function bytesToHex(value) {
+    return "0x" + Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(value) {
+    const hex = normalizeHex(value).slice(2);
+    if (hex.length % 2 !== 0 || !/^[0-9a-f]*$/.test(hex))
+        throw new Error("invalid proof hex");
+    return Uint8Array.from(hex.match(/.{2}/g)?.map((byte) => Number.parseInt(byte, 16)) ?? []);
+}
+function decodeCompactBytes(encoded) {
+    if (encoded.length === 0)
+        throw new Error("invalid compact proof value");
+    const mode = encoded[0] & 3;
+    let length;
+    let prefixLength;
+    if (mode === 0) {
+        length = encoded[0] >>> 2;
+        prefixLength = 1;
+    }
+    else if (mode === 1) {
+        if (encoded.length < 2)
+            throw new Error("invalid compact proof value");
+        length = ((encoded[0] | (encoded[1] << 8)) >>> 2);
+        prefixLength = 2;
+    }
+    else if (mode === 2) {
+        if (encoded.length < 4)
+            throw new Error("invalid compact proof value");
+        length = new DataView(encoded.buffer, encoded.byteOffset, 4).getUint32(0, true) >>> 2;
+        prefixLength = 4;
+    }
+    else {
+        const lengthBytes = (encoded[0] >>> 2) + 4;
+        if (lengthBytes > 6 || encoded.length < 1 + lengthBytes) {
+            throw new Error("compact proof value is too large");
+        }
+        length = 0;
+        for (let index = 0; index < lengthBytes; index += 1) {
+            length += encoded[1 + index] * 2 ** (8 * index);
+        }
+        prefixLength = 1 + lengthBytes;
+    }
+    if (!Number.isSafeInteger(length) || prefixLength + length !== encoded.length) {
+        throw new Error("invalid compact proof value length");
+    }
+    return encoded.slice(prefixLength);
+}

package/dist/rpc.d.ts

@@ -0,0 +1,115 @@
+export type FinalizedContext = {
+    blockHash: string;
+    blockNumber: number;
+    stateRoot: string;
+    slot: number;
+};
+export type SubmitWorkRequest = {
+    context: {
+        blockHash: string;
+        stateRoot: string;
+        slot: number;
+    };
+    serviceId: number;
+    serviceCodeHash: string;
+    payloadBase64: string;
+    extrinsicsBase64: string[];
+};
+export type SubmitWorkResult = {
+    packageHash: string;
+    submissionHash: string;
+    context: FinalizedContext;
+    /** Hash of the exact SignedActionV1 bytes submitted by submitAction. */
+    actionHash?: string;
+};
+export type SubmitTransactionRequest = {
+    serviceId: number;
+    serviceCodeHash: string;
+    payloadBase64: string;
+    extrinsicsBase64: string[];
+};
+export type TransactionState = "queued" | "packaged" | "refining" | "reported" | "imported" | "failed";
+export type SubmitTransactionResult = {
+    transactionId: string;
+    status: TransactionState;
+    packageHash?: string | null;
+    itemIndex?: number | null;
+    actionIndex?: number | null;
+};
+export type SubmitActionResult = SubmitTransactionResult & {
+    actionHash: string;
+};
+export type TransactionStatusResult = {
+    transactionId: string;
+    status: TransactionState;
+    packageHash: string | null;
+    itemIndex: number | null;
+    actionIndex: number | null;
+    executionReceipt: string | null;
+    error: string | null;
+    actionReceipts?: ActionReceipt[];
+};
+export type WorkStatus = "insufficient_workers" | "awaiting_candidate" | "voting" | "accepted" | "imported" | "failed";
+export type WorkStatusResult = {
+    packageHash: string;
+    workId: number | null;
+    status: WorkStatus;
+    executionReceipt: string | null;
+    actionReceipts?: ActionReceipt[];
+    context: FinalizedContext;
+};
+export type ActionReceipt = {
+    actionHash: string;
+    status: "applied" | "failed" | "rejected";
+    errorCode: number | null;
+};
+export type ManagedStateResult = {
+    serviceId: number;
+    stateRoot?: string;
+    managedStateRoot?: string;
+    serviceKey?: string;
+    keyBase64: string;
+    valueBase64: string | null;
+    proofBase64?: string[];
+    finalizedContext?: FinalizedContext;
+};
+export type BackendCapabilitiesV1 = {
+    protocolVersion: number;
+    managedStateVersion: number;
+    multiService: boolean;
+    externalStateWitness: boolean;
+    dynamicPvmServices: boolean;
+};
+export declare class RpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(message: string, code: number, data?: unknown | undefined);
+}
+export interface RpcTransport {
+    call<T>(method: string, params?: unknown): Promise<T>;
+}
+export declare class SplitRpcTransport implements RpcTransport {
+    private readonly node;
+    private readonly work;
+    private readonly state;
+    constructor(node: RpcTransport, work: RpcTransport, state?: RpcTransport);
+    call<T>(method: string, params?: unknown): Promise<T>;
+}
+export declare class FetchRpcTransport implements RpcTransport {
+    private readonly endpoint;
+    private readonly fetchImpl;
+    private nextId;
+    constructor(endpoint: string, fetchImpl?: typeof fetch);
+    call<T>(method: string, params?: unknown): Promise<T>;
+}
+export type WorkRpc = RpcTransport & {
+    finalizedContext(): Promise<FinalizedContext>;
+    genesisHash(): Promise<string>;
+    serviceStorageAt(blockHash: string, serviceId: number, key: string): Promise<string | null>;
+    managedStateAt(serviceId: number, stateRoot: string, keyBase64: string): Promise<ManagedStateResult>;
+    submitWork(request: SubmitWorkRequest): Promise<SubmitWorkResult>;
+    workStatus(packageHash: string, serviceId?: number): Promise<WorkStatusResult>;
+    submitTransaction(request: SubmitTransactionRequest): Promise<SubmitTransactionResult>;
+    transactionStatus(transactionId: string): Promise<TransactionStatusResult>;
+};
+export declare function asWorkRpc(transport: RpcTransport): WorkRpc;