@stelis/agent-q-core 0.0.0

package/dist/protocol.js

@@ -0,0 +1,897 @@
+import { IDENTIFICATION_CODE_PATTERN, MAX_FIRMWARE_NAME_LENGTH, MAX_FIRMWARE_VERSION_LENGTH, MAX_HARDWARE_ID_LENGTH, isDeviceState, isClientName, isProvisioningState, isSafeDeviceId, isSafeRequestId, isSessionId, sanitizeDisplayText, } from "./safe-text.js";
+import { makeConnectRequest as makeProviderConnectRequest, makeDisconnectRequest as makeProviderDisconnectRequest, makeGetAccountsRequest as makeProviderGetAccountsRequest, makeGetCapabilitiesRequest as makeProviderGetCapabilitiesRequest, parseProviderProtocolResponse as parseProviderProtocolResponseCore, validateSignPersonalMessageParams as validateProviderSignPersonalMessageParams, validateSignPersonalMessageInput as validateProviderSignPersonalMessageInput, validateSignTransactionParams as validateProviderSignTransactionParams, validateSignTransactionInput as validateProviderSignTransactionInput, } from "./provider-protocol.js";
+import { ProtocolError } from "./protocol-error.js";
+import { AGENT_Q_POLICY_SCHEMA, APPROVAL_HISTORY_HIGHEST_ACTIONS, APPROVAL_HISTORY_POLICY_UPDATE_RESULTS, APPROVAL_HISTORY_REASON_CODE_PATTERN, APPROVAL_HISTORY_RULE_REF_PATTERN, MAX_APPROVAL_HISTORY_RECORDS, MAX_POLICY_CHAIN_ID_LENGTH, MAX_POLICY_CRITERION_VALUES, MAX_POLICY_FIELD_ID_LENGTH, MAX_POLICY_METHOD_LENGTH, MAX_POLICY_RULE_CRITERIA, MAX_POLICY_RULE_COUNT, MAX_POLICY_RULE_ID_LENGTH, MAX_POLICY_UPDATE_REQUEST_JSON_BYTES, MAX_POLICY_VALUE_LENGTH, POLICY_ACTIONS, POLICY_FIELD_ID_PATTERN, POLICY_ID_PATTERN, POLICY_IDENTIFIER_PATTERN, POLICY_OPERATORS, POLICY_PROPOSE_RESULT_STATUSES, POLICY_RULE_ID_PATTERN, SIGNING_HISTORY_RECORD_KINDS, SIGNING_HISTORY_TERMINAL_RESULTS, SIGN_CHAIN_PATTERN, SIGN_METHOD_PATTERN, UINT_DECIMAL_STRING_PATTERN, } from "./protocol-management-primitives.js";
+import { ED25519_PUBLIC_KEY_BASE64_PATTERN, FORBIDDEN_SECRET_FIELD_NAMES, MAX_ACCOUNTS_PER_RESPONSE, MAX_CAPABILITY_ACCOUNTS_PER_CHAIN, MAX_CAPABILITY_CHAINS, MAX_PROTOCOL_RESPONSE_LINE_BYTES, MAX_RAW_PROTOCOL_JSON_BYTES, MAX_SESSION_TTL_MS, MAX_SIGN_RESULT_PAYLOAD_BASE64_CHARS, MAX_SIGNING_CAPABILITIES, MAX_SUI_SIGN_PERSONAL_MESSAGE_BASE64_CHARS, MAX_SUI_SIGN_PERSONAL_MESSAGE_BYTES, MAX_SUI_SIGN_TRANSACTION_TX_BYTES, MAX_SUI_SIGN_TRANSACTION_TX_BYTES_BASE64_CHARS, PROTOCOL_VERSION, SIGN_RESULT_ERROR_MESSAGES, SUI_ADDRESS_PATTERN, SUI_CHAIN_ID, SUI_DERIVATION_PATH, SUI_ED25519_SIGNATURE_BASE64_PATTERN, SUI_SIGN_PERSONAL_MESSAGE_METHOD, SUI_SIGN_TRANSACTION_METHOD, SUI_SIGN_TRANSACTION_NETWORKS, UNSUPPORTED_METHOD_MESSAGE, consumeProtocolResponseChunk, createRequestId, hasOnlyObjectKeys, hasSecretPayloadKey, isRecord, isSuiAddressForPublicKey, randomBytesPortable, utf8ByteLength, } from "./protocol-primitives.js";
+// These boundary functions are defined once in safe-text.ts (the single source of
+// truth) and re-exported here because protocol.ts is the wire-ingress boundary
+// that applies them; existing importers and tests resolve them via protocol.ts.
+export { isClientName, isSafeDeviceId, isSafeRequestId, isSessionId, sanitizeDisplayText };
+export { AGENT_Q_POLICY_SCHEMA, APPROVAL_HISTORY_HIGHEST_ACTIONS, APPROVAL_HISTORY_POLICY_UPDATE_RESULTS, APPROVAL_HISTORY_REASON_CODE_PATTERN, APPROVAL_HISTORY_RULE_REF_PATTERN, ED25519_PUBLIC_KEY_BASE64_PATTERN, FORBIDDEN_SECRET_FIELD_NAMES, MAX_ACCOUNTS_PER_RESPONSE, MAX_APPROVAL_HISTORY_RECORDS, MAX_CAPABILITY_ACCOUNTS_PER_CHAIN, MAX_CAPABILITY_CHAINS, MAX_POLICY_CHAIN_ID_LENGTH, MAX_POLICY_CRITERION_VALUES, MAX_POLICY_FIELD_ID_LENGTH, MAX_POLICY_METHOD_LENGTH, MAX_POLICY_RULE_CRITERIA, MAX_POLICY_RULE_COUNT, MAX_POLICY_RULE_ID_LENGTH, MAX_POLICY_UPDATE_REQUEST_JSON_BYTES, MAX_POLICY_VALUE_LENGTH, MAX_PROTOCOL_RESPONSE_LINE_BYTES, MAX_RAW_PROTOCOL_JSON_BYTES, MAX_SESSION_TTL_MS, MAX_SIGN_RESULT_PAYLOAD_BASE64_CHARS, MAX_SIGNING_CAPABILITIES, MAX_SUI_SIGN_PERSONAL_MESSAGE_BASE64_CHARS, MAX_SUI_SIGN_PERSONAL_MESSAGE_BYTES, MAX_SUI_SIGN_TRANSACTION_TX_BYTES, MAX_SUI_SIGN_TRANSACTION_TX_BYTES_BASE64_CHARS, POLICY_ACTIONS, POLICY_FIELD_ID_PATTERN, POLICY_ID_PATTERN, POLICY_IDENTIFIER_PATTERN, POLICY_OPERATORS, POLICY_PROPOSE_RESULT_STATUSES, POLICY_RULE_ID_PATTERN, PROTOCOL_VERSION, SIGNING_HISTORY_RECORD_KINDS, SIGNING_HISTORY_TERMINAL_RESULTS, SIGN_CHAIN_PATTERN, SIGN_METHOD_PATTERN, SIGN_RESULT_ERROR_MESSAGES, SUI_ADDRESS_PATTERN, SUI_CHAIN_ID, SUI_DERIVATION_PATH, SUI_ED25519_SIGNATURE_BASE64_PATTERN, SUI_SIGN_PERSONAL_MESSAGE_METHOD, SUI_SIGN_TRANSACTION_METHOD, SUI_SIGN_TRANSACTION_NETWORKS, UINT_DECIMAL_STRING_PATTERN, UNSUPPORTED_METHOD_MESSAGE, consumeProtocolResponseChunk, createRequestId, isSuiAddressForPublicKey, };
+export { ProtocolError };
+// Signing request builders and route identification are owned by
+// provider-protocol because provider adapters and the full protocol share the
+// same top-level signing methods. The full protocol entrypoint re-exports them
+// for compatibility instead of wrapping or reclassifying the route.
+export { identifySignRoute, makeSignPersonalMessageRequest, makeSignTransactionRequest, } from "./provider-protocol.js";
+export function makeGetStatusRequest(id = createRequestId()) {
+    validateRequestId(id);
+    return {
+        id,
+        version: PROTOCOL_VERSION,
+        type: "get_status",
+    };
+}
+export function makeIdentifyDeviceRequest(code, id = createRequestId()) {
+    validateRequestId(id);
+    if (!isIdentificationCode(code)) {
+        throw new ProtocolError("invalid_code", "Invalid identification code.");
+    }
+    return {
+        id,
+        version: PROTOCOL_VERSION,
+        type: "identify_device",
+        params: {
+            code,
+        },
+    };
+}
+export function createIdentificationCode() {
+    const bytes = randomBytesPortable(2);
+    return ((((bytes[0] ?? 0) << 8) | (bytes[1] ?? 0)) % 10000).toString().padStart(4, "0");
+}
+export const makeConnectRequest = makeProviderConnectRequest;
+export const makeDisconnectRequest = makeProviderDisconnectRequest;
+export const makeGetCapabilitiesRequest = makeProviderGetCapabilitiesRequest;
+export const makeGetAccountsRequest = makeProviderGetAccountsRequest;
+export function makePolicyGetRequest(sessionId, id = createRequestId()) {
+    validateRequestId(id);
+    if (!isSessionId(sessionId)) {
+        throw new ProtocolError("invalid_session", "Invalid sessionId.");
+    }
+    return {
+        id,
+        version: PROTOCOL_VERSION,
+        type: "policy_get",
+        sessionId,
+    };
+}
+export function makeGetApprovalHistoryRequest(sessionId, params = {}, id = createRequestId()) {
+    validateRequestId(id);
+    if (!isSessionId(sessionId)) {
+        throw new ProtocolError("invalid_session", "Invalid sessionId.");
+    }
+    const normalizedParams = validateApprovalHistoryInput(params);
+    return {
+        id,
+        version: PROTOCOL_VERSION,
+        type: "get_approval_history",
+        sessionId,
+        params: normalizedParams,
+    };
+}
+export function makePolicyProposeRequest(sessionId, policy, id = createRequestId()) {
+    validateRequestId(id);
+    if (!isSessionId(sessionId)) {
+        throw new ProtocolError("invalid_session", "Invalid sessionId.");
+    }
+    validatePolicyProposeInput(policy);
+    const request = {
+        id,
+        version: PROTOCOL_VERSION,
+        type: "policy_propose",
+        sessionId,
+        params: {
+            policy,
+        },
+    };
+    if (utf8ByteLength(JSON.stringify(request)) > MAX_POLICY_UPDATE_REQUEST_JSON_BYTES) {
+        throw new ProtocolError("invalid_params", "policy_propose request is too large for the runtime.");
+    }
+    return request;
+}
+export function validatePolicyProposeRequestInput(sessionId, policy) {
+    makePolicyProposeRequest(sessionId, policy, "req_000000000000000000000000");
+}
+export function validateSignRequestInput(chain, method, params, requestType = "sign") {
+    return validateProviderSignTransactionInput(chain, method, params, requestType);
+}
+export function validateSignTransactionParamsInput(params, requestType = "sign_transaction") {
+    return validateProviderSignTransactionParams(params, requestType);
+}
+export function validateSignPersonalMessageRequestInput(chain, method, params, requestType = "sign_personal_message") {
+    return validateProviderSignPersonalMessageInput(chain, method, params, requestType);
+}
+export function validateSignPersonalMessageParamsInput(params, requestType = "sign_personal_message") {
+    return validateProviderSignPersonalMessageParams(params, requestType);
+}
+export function validatePolicyProposeInput(policy) {
+    if (!isRecord(policy) || Array.isArray(policy)) {
+        throw new ProtocolError("invalid_params", "policy_propose policy must be an object.");
+    }
+    if (hasSecretPayloadKey(policy)) {
+        throw new ProtocolError("invalid_params", "policy_propose policy must not include secret material.");
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(policy);
+    }
+    catch {
+        throw new ProtocolError("invalid_params", "policy_propose policy must be JSON serializable.");
+    }
+    if (serialized === undefined) {
+        throw new ProtocolError("invalid_params", "policy_propose policy must be JSON serializable.");
+    }
+}
+export function validateApprovalHistoryInput(params = {}) {
+    const limit = params.limit ?? MAX_APPROVAL_HISTORY_RECORDS;
+    if (!Number.isInteger(limit) || limit <= 0 || limit > MAX_APPROVAL_HISTORY_RECORDS) {
+        throw new ProtocolError("invalid_params", "approval history limit is invalid.");
+    }
+    if (params.beforeSeq !== undefined && !isUint64DecimalString(params.beforeSeq)) {
+        throw new ProtocolError("invalid_params", "approval history beforeSeq is invalid.");
+    }
+    return params.beforeSeq === undefined ? { limit } : { limit, beforeSeq: params.beforeSeq };
+}
+export function serializeRequest(request) {
+    return `${JSON.stringify(request)}\n`;
+}
+export function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        throw new ProtocolError("invalid_json", "Invalid JSON response.");
+    }
+}
+export function parseProtocolResponse(line, expectedId) {
+    const value = parseJsonLine(line);
+    if (!isRecord(value)) {
+        throw new ProtocolError("protocol_error", "Protocol response must be an object.");
+    }
+    if (value.version !== PROTOCOL_VERSION) {
+        throw new ProtocolError("incompatible_version", "Unsupported protocol response version.");
+    }
+    if (expectedId !== undefined && value.id !== expectedId) {
+        throw new ProtocolError("protocol_error", "Protocol response id does not match request id.");
+    }
+    if (isProviderProtocolResponseType(value.type)) {
+        return parseProviderProtocolResponse(line, expectedId);
+    }
+    if (value.type === "status") {
+        if (!hasOnlyObjectKeys(value, ["id", "version", "type", "device", "provisioning"])) {
+            throw new ProtocolError("protocol_error", "Status response contains unsupported fields.");
+        }
+        requireWireDeviceStatusShape(value.device, "Status response device object");
+        requireWireProvisioningStatusShape(value.provisioning, "Status response provisioning object");
+        const device = sanitizeDeviceStatus(value.device);
+        if (device === null) {
+            throw new ProtocolError("protocol_error", "Status response device object is malformed.");
+        }
+        const provisioning = sanitizeProvisioningStatus(value.provisioning);
+        if (provisioning === null) {
+            throw new ProtocolError("protocol_error", "Status response provisioning object is malformed.");
+        }
+        if (typeof value.id !== "string") {
+            throw new ProtocolError("protocol_error", "Status response id is malformed.");
+        }
+        return {
+            id: value.id,
+            version: PROTOCOL_VERSION,
+            type: "status",
+            device,
+            provisioning,
+        };
+    }
+    if (value.type === "identify_device_result") {
+        if (!hasOnlyObjectKeys(value, ["id", "version", "type", "status", "code", "device"])) {
+            throw new ProtocolError("protocol_error", "Identify response contains unsupported fields.");
+        }
+        requireWireDeviceStatusShape(value.device, "Identify response device object");
+        const device = sanitizeDeviceStatus(value.device);
+        if (device === null) {
+            throw new ProtocolError("protocol_error", "Identify response device object is malformed.");
+        }
+        if (typeof value.id !== "string" || value.status !== "displayed" || !isIdentificationCode(value.code)) {
+            throw new ProtocolError("protocol_error", "Identify response is malformed.");
+        }
+        return {
+            id: value.id,
+            version: PROTOCOL_VERSION,
+            type: "identify_device_result",
+            status: "displayed",
+            code: value.code,
+            device,
+        };
+    }
+    if (value.type === "policy") {
+        if (typeof value.id !== "string") {
+            throw new ProtocolError("protocol_error", "Policy response id is malformed.");
+        }
+        if (hasSecretPayloadKey(value)) {
+            throw new ProtocolError("protocol_error", "Policy response must not include secret material.");
+        }
+        if (!hasOnlyObjectKeys(value, ["id", "version", "type", "policy"])) {
+            throw new ProtocolError("protocol_error", "Policy response contains unsupported fields.");
+        }
+        const policy = sanitizeCurrentPolicyDocument(value.policy);
+        if (policy === null) {
+            throw new ProtocolError("protocol_error", "Policy response policy object is malformed.");
+        }
+        return {
+            id: value.id,
+            version: PROTOCOL_VERSION,
+            type: "policy",
+            policy,
+        };
+    }
+    if (value.type === "approval_history") {
+        if (typeof value.id !== "string") {
+            throw new ProtocolError("protocol_error", "Approval history response id is malformed.");
+        }
+        if (hasSecretPayloadKey(value)) {
+            throw new ProtocolError("protocol_error", "Approval history response must not include secret material.");
+        }
+        if (!hasOnlyObjectKeys(value, ["id", "version", "type", "records", "hasMore"])) {
+            throw new ProtocolError("protocol_error", "Approval history response contains unsupported fields.");
+        }
+        if (!Array.isArray(value.records) || value.records.length > MAX_APPROVAL_HISTORY_RECORDS) {
+            throw new ProtocolError("protocol_error", "Approval history response records are malformed.");
+        }
+        if (typeof value.hasMore !== "boolean") {
+            throw new ProtocolError("protocol_error", "Approval history response hasMore is malformed.");
+        }
+        return {
+            id: value.id,
+            version: PROTOCOL_VERSION,
+            type: "approval_history",
+            records: value.records.map((entry) => sanitizeApprovalHistoryRecord(entry)),
+            hasMore: value.hasMore,
+        };
+    }
+    if (value.type === "policy_propose_result") {
+        if (typeof value.id !== "string") {
+            throw new ProtocolError("protocol_error", "policy_propose_result id is malformed.");
+        }
+        if (hasSecretPayloadKey(value)) {
+            throw new ProtocolError("protocol_error", "policy_propose_result must not include secret material.");
+        }
+        if (!hasOnlyObjectKeys(value, ["id", "version", "type", "status", "reasonCode", "policy"])) {
+            throw new ProtocolError("protocol_error", "policy_propose_result contains unsupported fields.");
+        }
+        if (!POLICY_PROPOSE_RESULT_STATUSES.includes(value.status) ||
+            typeof value.reasonCode !== "string" ||
+            !APPROVAL_HISTORY_REASON_CODE_PATTERN.test(value.reasonCode)) {
+            throw new ProtocolError("protocol_error", "policy_propose_result is malformed.");
+        }
+        const policy = sanitizePolicyProposeResultPolicy(value.policy);
+        if (value.status === "invalid_policy") {
+            if (policy !== undefined) {
+                throw new ProtocolError("protocol_error", "Invalid policy result must not include policy metadata.");
+            }
+        }
+        else if (policy === undefined) {
+            throw new ProtocolError("protocol_error", "policy_propose_result policy metadata is malformed.");
+        }
+        return {
+            id: value.id,
+            version: PROTOCOL_VERSION,
+            type: "policy_propose_result",
+            status: value.status,
+            reasonCode: value.reasonCode,
+            ...(policy !== undefined ? { policy } : {}),
+        };
+    }
+    throw new ProtocolError("protocol_error", "Protocol response type is unsupported.");
+}
+export function parseProviderProtocolResponse(line, expectedId) {
+    return parseProviderProtocolResponseCore(line, expectedId);
+}
+function isProviderProtocolResponseType(value) {
+    return (value === "error" ||
+        value === "connect_result" ||
+        value === "disconnect_result" ||
+        value === "capabilities" ||
+        value === "accounts" ||
+        value === "sign_result");
+}
+export function assertStatusResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "status") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not status.");
+    }
+    return response;
+}
+export function assertIdentifyDeviceResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "identify_device_result") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not identify_device_result.");
+    }
+    return response;
+}
+export function assertConnectResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "connect_result") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not connect_result.");
+    }
+    return response;
+}
+export function assertDisconnectResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "disconnect_result") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not disconnect_result.");
+    }
+    return response;
+}
+export function assertCapabilitiesResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "capabilities") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not capabilities.");
+    }
+    return response;
+}
+export function assertAccountsResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "accounts") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not accounts.");
+    }
+    return response;
+}
+export function assertPolicyResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "policy") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not policy.");
+    }
+    return response;
+}
+export function assertApprovalHistoryResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "approval_history") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not approval_history.");
+    }
+    return response;
+}
+export function assertPolicyProposeResultResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "policy_propose_result") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not policy_propose_result.");
+    }
+    return response;
+}
+export function assertSignResultResponse(response) {
+    if (response.type === "error") {
+        throw new ProtocolError(response.error.code, response.error.message);
+    }
+    if (response.type !== "sign_result") {
+        throw new ProtocolError("protocol_error", "Protocol response type is not sign_result.");
+    }
+    return response;
+}
+// Reduce an untrusted wire or stored device object to a safe DeviceStatus, or
+// null when its identity fields are unusable. deviceId and state are REJECTED
+// when malformed (returns null); the display strings are sanitized to bounded
+// printable ASCII. Shared by the wire boundary (above) and the disk boundary
+// (config.ts) so both apply the identical policy.
+export function sanitizeDeviceStatus(value) {
+    if (!isRecord(value) || !isSafeDeviceId(value.deviceId) || !isDeviceState(value.state)) {
+        return null;
+    }
+    return {
+        deviceId: value.deviceId,
+        state: value.state,
+        firmwareName: sanitizeDisplayText(value.firmwareName, MAX_FIRMWARE_NAME_LENGTH),
+        hardware: sanitizeDisplayText(value.hardware, MAX_HARDWARE_ID_LENGTH),
+        firmwareVersion: sanitizeDisplayText(value.firmwareVersion, MAX_FIRMWARE_VERSION_LENGTH),
+    };
+}
+export function sanitizeProvisioningStatus(value) {
+    if (!isRecord(value) || !isProvisioningState(value.state)) {
+        return null;
+    }
+    return { state: value.state };
+}
+export function isSignChain(value) {
+    return typeof value === "string" && SIGN_CHAIN_PATTERN.test(value);
+}
+export function isSignMethod(value) {
+    return typeof value === "string" && SIGN_METHOD_PATTERN.test(value);
+}
+export function isUint64DecimalString(value) {
+    if (typeof value !== "string" || !UINT_DECIMAL_STRING_PATTERN.test(value)) {
+        return false;
+    }
+    return value.length < UINT64_MAX_DECIMAL.length ||
+        (value.length === UINT64_MAX_DECIMAL.length && value <= UINT64_MAX_DECIMAL);
+}
+const UINT64_MAX_DECIMAL = "18446744073709551615";
+function isBoundedPolicyString(value, maxLength) {
+    return typeof value === "string" && value.length > 0 && value.length <= maxLength;
+}
+function isPolicyIdentifierString(value, maxLength) {
+    return isBoundedPolicyString(value, maxLength) && POLICY_IDENTIFIER_PATTERN.test(value);
+}
+const COMMON_POLICY_FIELDS = {
+    "common.chain": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "common.method": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "common.intent": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+};
+const SUI_SIGN_TRANSACTION_POLICY_FIELDS = {
+    "sui.command_shape": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.sender_address": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.gas_owner_address": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.command_count": { type: "u64_decimal", allowEq: true, allowIn: false, allowLte: true },
+    "sui.command0_kind": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.command1_kind": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.recipient_address": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.coin_type": { type: "string", allowEq: true, allowIn: true, allowLte: false },
+    "sui.amount_raw": { type: "u64_decimal", allowEq: true, allowIn: false, allowLte: true },
+    "sui.gas_budget": { type: "u64_decimal", allowEq: true, allowIn: false, allowLte: true },
+    "sui.gas_price": { type: "u64_decimal", allowEq: true, allowIn: false, allowLte: true },
+};
+function policyRuleHasSupportedMethod(rule) {
+    return rule.chain === SUI_CHAIN_ID && rule.method === SUI_SIGN_TRANSACTION_METHOD;
+}
+function findPolicyFieldDescriptor(rule, field) {
+    if (!policyRuleHasSupportedMethod(rule)) {
+        return null;
+    }
+    return COMMON_POLICY_FIELDS[field] ?? SUI_SIGN_TRANSACTION_POLICY_FIELDS[field] ?? null;
+}
+function policyOperatorAllowed(descriptor, op) {
+    switch (op) {
+        case "eq":
+            return descriptor.allowEq;
+        case "in":
+            return descriptor.allowIn;
+        case "lte":
+            return descriptor.allowLte;
+    }
+}
+function policyCriterionMatchesDescriptor(rule, criterion) {
+    const descriptor = findPolicyFieldDescriptor(rule, criterion.field);
+    if (descriptor === null || !policyOperatorAllowed(descriptor, criterion.op)) {
+        return false;
+    }
+    if (criterion.op === "in") {
+        if (criterion.values === undefined || criterion.value !== undefined) {
+            return false;
+        }
+        return descriptor.type !== "u64_decimal" ||
+            criterion.values.every((value) => isUint64DecimalString(value));
+    }
+    if (criterion.value === undefined || criterion.values !== undefined) {
+        return false;
+    }
+    return descriptor.type !== "u64_decimal" || isUint64DecimalString(criterion.value);
+}
+function policyCriterionEq(criterion, field, value) {
+    return criterion.field === field &&
+        criterion.op === "eq" &&
+        criterion.value === value;
+}
+function policyCriterionLte(criterion, field) {
+    return criterion.field === field &&
+        criterion.op === "lte" &&
+        criterion.value !== undefined &&
+        isUint64DecimalString(criterion.value);
+}
+function policyCriterionU64Eq(criterion, field, value) {
+    return policyCriterionEq(criterion, field, value) &&
+        criterion.value !== undefined &&
+        isUint64DecimalString(criterion.value);
+}
+function policyRecipientIsBounded(criterion) {
+    if (criterion.field !== "sui.recipient_address") {
+        return false;
+    }
+    if (criterion.op === "eq") {
+        return criterion.value !== undefined && criterion.value.length > 0;
+    }
+    return criterion.op === "in" &&
+        criterion.values !== undefined &&
+        criterion.values.length === 1;
+}
+function policySignRuleIsBounded(rule) {
+    if (rule.action !== "sign") {
+        return true;
+    }
+    if (rule.chain !== SUI_CHAIN_ID ||
+        rule.method !== SUI_SIGN_TRANSACTION_METHOD ||
+        rule.criteria.length === 0) {
+        return false;
+    }
+    let hasIntent = false;
+    let hasShape = false;
+    let hasAsset = false;
+    let hasCommandCount = false;
+    let hasCommand0Kind = false;
+    let hasCommand1Kind = false;
+    let hasRecipient = false;
+    let hasAmountBound = false;
+    let hasGasBudgetBound = false;
+    let hasGasPriceBound = false;
+    for (const criterion of rule.criteria) {
+        hasIntent = hasIntent || policyCriterionEq(criterion, "common.intent", "single_asset_transfer");
+        hasShape = hasShape || policyCriterionEq(criterion, "sui.command_shape", "restricted_transfer");
+        hasAsset = hasAsset || policyCriterionEq(criterion, "sui.coin_type", "0x2::sui::SUI");
+        hasCommandCount = hasCommandCount || policyCriterionU64Eq(criterion, "sui.command_count", "2");
+        hasCommand0Kind = hasCommand0Kind || policyCriterionEq(criterion, "sui.command0_kind", "split_coins");
+        hasCommand1Kind = hasCommand1Kind || policyCriterionEq(criterion, "sui.command1_kind", "transfer_objects");
+        hasRecipient = hasRecipient || policyRecipientIsBounded(criterion);
+        hasAmountBound = hasAmountBound || policyCriterionLte(criterion, "sui.amount_raw");
+        hasGasBudgetBound = hasGasBudgetBound || policyCriterionLte(criterion, "sui.gas_budget");
+        hasGasPriceBound = hasGasPriceBound || policyCriterionLte(criterion, "sui.gas_price");
+    }
+    return hasIntent &&
+        hasShape &&
+        hasAsset &&
+        hasCommandCount &&
+        hasCommand0Kind &&
+        hasCommand1Kind &&
+        hasRecipient &&
+        hasAmountBound &&
+        hasGasBudgetBound &&
+        hasGasPriceBound;
+}
+function sanitizePolicyCriterion(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (hasSecretPayloadKey(value)) {
+        throw new ProtocolError("protocol_error", "Policy criterion must not include secret material.");
+    }
+    if (!isBoundedPolicyString(value.field, MAX_POLICY_FIELD_ID_LENGTH) ||
+        !POLICY_FIELD_ID_PATTERN.test(value.field) ||
+        typeof value.op !== "string" ||
+        !POLICY_OPERATORS.includes(value.op)) {
+        return null;
+    }
+    const op = value.op;
+    if (op === "in") {
+        if (!hasOnlyObjectKeys(value, ["field", "op", "values"])) {
+            throw new ProtocolError("protocol_error", "Policy criterion contains unsupported fields.");
+        }
+        if (!Array.isArray(value.values) ||
+            value.values.length === 0 ||
+            value.values.length > MAX_POLICY_CRITERION_VALUES ||
+            !value.values.every((item) => isBoundedPolicyString(item, MAX_POLICY_VALUE_LENGTH))) {
+            return null;
+        }
+        return {
+            field: value.field,
+            op,
+            values: [...value.values],
+        };
+    }
+    if (!hasOnlyObjectKeys(value, ["field", "op", "value"])) {
+        throw new ProtocolError("protocol_error", "Policy criterion contains unsupported fields.");
+    }
+    if (!isBoundedPolicyString(value.value, MAX_POLICY_VALUE_LENGTH)) {
+        return null;
+    }
+    return {
+        field: value.field,
+        op,
+        value: value.value,
+    };
+}
+function sanitizePolicyRule(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (hasSecretPayloadKey(value)) {
+        throw new ProtocolError("protocol_error", "Policy rule must not include secret material.");
+    }
+    if (!hasOnlyObjectKeys(value, ["id", "chain", "method", "action", "criteria"])) {
+        throw new ProtocolError("protocol_error", "Policy rule contains unsupported fields.");
+    }
+    if (!isBoundedPolicyString(value.id, MAX_POLICY_RULE_ID_LENGTH) ||
+        !POLICY_RULE_ID_PATTERN.test(value.id) ||
+        !isPolicyIdentifierString(value.chain, MAX_POLICY_CHAIN_ID_LENGTH) ||
+        !isPolicyIdentifierString(value.method, MAX_POLICY_METHOD_LENGTH) ||
+        typeof value.action !== "string" ||
+        !POLICY_ACTIONS.includes(value.action) ||
+        !Array.isArray(value.criteria) ||
+        value.criteria.length > MAX_POLICY_RULE_CRITERIA) {
+        return null;
+    }
+    const criteria = value.criteria.map((criterion) => sanitizePolicyCriterion(criterion));
+    if (criteria.some((criterion) => criterion === null)) {
+        return null;
+    }
+    const rule = {
+        id: value.id,
+        chain: value.chain,
+        method: value.method,
+        action: value.action,
+        criteria: criteria,
+    };
+    if (!policyRuleHasSupportedMethod(rule) ||
+        !rule.criteria.every((criterion) => policyCriterionMatchesDescriptor(rule, criterion)) ||
+        !policySignRuleIsBounded(rule)) {
+        return null;
+    }
+    return rule;
+}
+export function sanitizeCurrentPolicyDocument(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (hasSecretPayloadKey(value)) {
+        throw new ProtocolError("protocol_error", "Policy document must not include secret material.");
+    }
+    if (!hasOnlyObjectKeys(value, ["schema", "policyId", "defaultAction", "ruleCount", "rules"])) {
+        throw new ProtocolError("protocol_error", "Policy document contains unsupported fields.");
+    }
+    if (value.schema !== AGENT_Q_POLICY_SCHEMA ||
+        typeof value.policyId !== "string" ||
+        !POLICY_ID_PATTERN.test(value.policyId) ||
+        value.defaultAction !== "reject" ||
+        typeof value.ruleCount !== "number" ||
+        !Number.isInteger(value.ruleCount) ||
+        value.ruleCount < 0 ||
+        value.ruleCount > MAX_POLICY_RULE_COUNT ||
+        !Array.isArray(value.rules) ||
+        value.rules.length !== value.ruleCount) {
+        return null;
+    }
+    const rules = value.rules.map((rule) => sanitizePolicyRule(rule));
+    if (rules.some((rule) => rule === null)) {
+        return null;
+    }
+    const signRuleCount = rules.filter((rule) => rule?.action === "sign").length;
+    if (signRuleCount > 1) {
+        return null;
+    }
+    return {
+        schema: value.schema,
+        policyId: value.policyId,
+        defaultAction: value.defaultAction,
+        ruleCount: value.ruleCount,
+        rules: rules,
+    };
+}
+function sanitizePolicyProposeResultPolicy(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        throw new ProtocolError("protocol_error", "policy_propose_result policy metadata is malformed.");
+    }
+    if (hasSecretPayloadKey(value)) {
+        throw new ProtocolError("protocol_error", "policy_propose_result policy metadata must not include secret material.");
+    }
+    if (!hasOnlyObjectKeys(value, ["policyHash", "ruleCount", "highestAction"])) {
+        throw new ProtocolError("protocol_error", "policy_propose_result policy metadata contains unsupported fields.");
+    }
+    if (typeof value.policyHash !== "string" ||
+        !POLICY_ID_PATTERN.test(value.policyHash) ||
+        typeof value.ruleCount !== "number" ||
+        !Number.isInteger(value.ruleCount) ||
+        value.ruleCount < 0 ||
+        value.ruleCount > MAX_POLICY_RULE_COUNT ||
+        !APPROVAL_HISTORY_HIGHEST_ACTIONS.includes(value.highestAction)) {
+        throw new ProtocolError("protocol_error", "policy_propose_result policy metadata is malformed.");
+    }
+    return {
+        policyHash: value.policyHash,
+        ruleCount: value.ruleCount,
+        highestAction: value.highestAction,
+    };
+}
+function sanitizeApprovalHistoryRecord(value) {
+    if (!isRecord(value)) {
+        throw new ProtocolError("protocol_error", "Approval history record is malformed.");
+    }
+    if (hasSecretPayloadKey(value)) {
+        throw new ProtocolError("protocol_error", "Approval history record must not include secret material.");
+    }
+    const allowedKeys = [
+        "seq",
+        "uptimeMs",
+        "timeSource",
+        "eventKind",
+        "confirmationKind",
+        "authorization",
+        "chain",
+        "method",
+        "reasonCode",
+        "payloadDigest",
+        "policyHash",
+        "ruleRef",
+        "result",
+        "ruleCount",
+        "highestAction",
+        "recordKind",
+        "terminalResult",
+    ];
+    if (!hasOnlyObjectKeys(value, allowedKeys)) {
+        throw new ProtocolError("protocol_error", "Approval history record contains unsupported fields.");
+    }
+    if (typeof value.seq !== "string" ||
+        !isUint64DecimalString(value.seq) ||
+        typeof value.uptimeMs !== "string" ||
+        !isUint64DecimalString(value.uptimeMs) ||
+        value.timeSource !== "uptime" ||
+        typeof value.reasonCode !== "string" ||
+        !APPROVAL_HISTORY_REASON_CODE_PATTERN.test(value.reasonCode)) {
+        throw new ProtocolError("protocol_error", "Approval history record is malformed.");
+    }
+    if (value.eventKind === "policy_update") {
+        if (value.confirmationKind !== undefined ||
+            value.chain !== undefined ||
+            value.method !== undefined ||
+            value.payloadDigest !== undefined ||
+            value.ruleRef !== undefined ||
+            value.recordKind !== undefined ||
+            value.terminalResult !== undefined ||
+            !APPROVAL_HISTORY_POLICY_UPDATE_RESULTS.includes(value.result) ||
+            typeof value.policyHash !== "string" ||
+            !POLICY_ID_PATTERN.test(value.policyHash) ||
+            typeof value.ruleCount !== "number" ||
+            !Number.isInteger(value.ruleCount) ||
+            value.ruleCount < 0 ||
+            value.ruleCount > MAX_POLICY_RULE_COUNT ||
+            !APPROVAL_HISTORY_HIGHEST_ACTIONS.includes(value.highestAction)) {
+            throw new ProtocolError("protocol_error", "Approval history policy update record is malformed.");
+        }
+        return {
+            seq: value.seq,
+            uptimeMs: value.uptimeMs,
+            timeSource: "uptime",
+            eventKind: "policy_update",
+            reasonCode: value.reasonCode,
+            result: value.result,
+            policyHash: value.policyHash,
+            ruleCount: value.ruleCount,
+            highestAction: value.highestAction,
+        };
+    }
+    if (value.eventKind === "signing") {
+        if (value.result !== undefined ||
+            value.ruleCount !== undefined ||
+            value.highestAction !== undefined ||
+            !SIGNING_HISTORY_RECORD_KINDS.includes(value.recordKind) ||
+            (value.authorization !== "user" && value.authorization !== "policy") ||
+            !isSignChain(value.chain) ||
+            !isSignMethod(value.method) ||
+            typeof value.payloadDigest !== "string" ||
+            !POLICY_ID_PATTERN.test(value.payloadDigest)) {
+            throw new ProtocolError("protocol_error", "Approval history signing record is malformed.");
+        }
+        if (value.recordKind === "confirmation") {
+            if (value.terminalResult !== undefined) {
+                throw new ProtocolError("protocol_error", "Approval history signing record is malformed.");
+            }
+            if (value.authorization === "user") {
+                if ((value.confirmationKind !== "local_pin" &&
+                    value.confirmationKind !== "physical_confirm") ||
+                    value.policyHash !== undefined ||
+                    value.ruleRef !== undefined) {
+                    throw new ProtocolError("protocol_error", "Approval history signing record is malformed.");
+                }
+                return {
+                    seq: value.seq,
+                    uptimeMs: value.uptimeMs,
+                    timeSource: "uptime",
+                    eventKind: "signing",
+                    reasonCode: value.reasonCode,
+                    recordKind: "confirmation",
+                    authorization: "user",
+                    confirmationKind: value.confirmationKind,
+                    chain: value.chain,
+                    method: value.method,
+                    payloadDigest: value.payloadDigest,
+                };
+            }
+            if (value.confirmationKind !== "policy" ||
+                typeof value.policyHash !== "string" ||
+                !POLICY_ID_PATTERN.test(value.policyHash) ||
+                typeof value.ruleRef !== "string" ||
+                !APPROVAL_HISTORY_RULE_REF_PATTERN.test(value.ruleRef)) {
+                throw new ProtocolError("protocol_error", "Approval history signing policy metadata is malformed.");
+            }
+            return {
+                seq: value.seq,
+                uptimeMs: value.uptimeMs,
+                timeSource: "uptime",
+                eventKind: "signing",
+                reasonCode: value.reasonCode,
+                recordKind: "confirmation",
+                authorization: "policy",
+                confirmationKind: "policy",
+                chain: value.chain,
+                method: value.method,
+                payloadDigest: value.payloadDigest,
+                policyHash: value.policyHash,
+                ruleRef: value.ruleRef,
+            };
+        }
+        if (value.confirmationKind !== undefined ||
+            !SIGNING_HISTORY_TERMINAL_RESULTS.includes(value.terminalResult)) {
+            throw new ProtocolError("protocol_error", "Approval history signing record is malformed.");
+        }
+        const terminalResult = value.terminalResult;
+        if (value.authorization === "policy") {
+            if (!["signed", "policy_rejected", "signing_failed"].includes(terminalResult) ||
+                typeof value.policyHash !== "string" ||
+                !POLICY_ID_PATTERN.test(value.policyHash) ||
+                typeof value.ruleRef !== "string" ||
+                !APPROVAL_HISTORY_RULE_REF_PATTERN.test(value.ruleRef)) {
+                throw new ProtocolError("protocol_error", "Approval history signing policy metadata is malformed.");
+            }
+        }
+        else if (!["signed", "user_rejected", "user_timed_out", "signing_failed"].includes(terminalResult) ||
+            value.policyHash !== undefined ||
+            value.ruleRef !== undefined) {
+            throw new ProtocolError("protocol_error", "Approval history signing policy metadata is malformed.");
+        }
+        return {
+            seq: value.seq,
+            uptimeMs: value.uptimeMs,
+            timeSource: "uptime",
+            eventKind: "signing",
+            reasonCode: value.reasonCode,
+            recordKind: "terminal",
+            authorization: value.authorization,
+            terminalResult,
+            chain: value.chain,
+            method: value.method,
+            payloadDigest: value.payloadDigest,
+            ...(value.authorization === "policy" ? {
+                policyHash: value.policyHash,
+                ruleRef: value.ruleRef,
+            } : {}),
+        };
+    }
+    throw new ProtocolError("protocol_error", "Approval history record is malformed.");
+}
+export function sanitizeDeviceStatusSnapshot(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const device = sanitizeDeviceStatus(value.device);
+    const provisioning = sanitizeProvisioningStatus(value.provisioning);
+    if (device === null || provisioning === null) {
+        return null;
+    }
+    return { device, provisioning };
+}
+function isIdentificationCode(value) {
+    return typeof value === "string" && IDENTIFICATION_CODE_PATTERN.test(value);
+}
+function validateRequestId(id) {
+    if (!isSafeRequestId(id)) {
+        throw new ProtocolError("invalid_id", "Invalid request id.");
+    }
+}
+function requireWireDeviceStatusShape(value, label) {
+    if (!isRecord(value) ||
+        !hasOnlyObjectKeys(value, ["deviceId", "state", "firmwareName", "hardware", "firmwareVersion"])) {
+        throw new ProtocolError("protocol_error", `${label} contains unsupported fields.`);
+    }
+}
+function requireWireProvisioningStatusShape(value, label) {
+    if (!isRecord(value) || !hasOnlyObjectKeys(value, ["state"])) {
+        throw new ProtocolError("protocol_error", `${label} contains unsupported fields.`);
+    }
+}
+//# sourceMappingURL=protocol.js.map