@frequency-chain/ethereum-utils 1.17.0-rc4

package/cjs/address.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRandomKey = createRandomKey;
+exports.ethereumAddressToKeyringPair = ethereumAddressToKeyringPair;
+exports.getUnifiedAddress = getUnifiedAddress;
+exports.getUnifiedPublicKey = getUnifiedPublicKey;
+exports.reverseUnifiedAddressToEthereumAddress = reverseUnifiedAddressToEthereumAddress;
+exports.getSS58AccountFromEthereumAccount = getSS58AccountFromEthereumAccount;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const ethers_1 = require("ethers");
+/**
+ * Creates a Random Ethereum key
+ */
+function createRandomKey() {
+    const k = ethers_1.ethers.Wallet.createRandom();
+    return {
+        publicKey: k.publicKey,
+        privateKey: k.privateKey,
+        address: {
+            ethereumAddress: k.address,
+            unifiedAddress: getUnified32BytesAddress(k.address),
+            unifiedAddressSS58: getSS58AccountFromEthereumAccount(k.address),
+        },
+        mnemonic: k.mnemonic?.phrase ?? '',
+    };
+}
+/**
+ * Create a partial KeyringPair from an Ethereum address
+ */
+function ethereumAddressToKeyringPair(ethereumAddress) {
+    return {
+        type: 'ethereum',
+        address: ethereumAddress.toHex(),
+        addressRaw: ethereumAddress,
+    };
+}
+/**
+ * Returns unified 32 bytes SS58 accountId
+ * @param pair
+ */
+function getUnifiedAddress(pair) {
+    if ('ethereum' === pair.type) {
+        const etheAddressHex = (0, util_crypto_1.ethereumEncode)(pair.publicKey || pair.address);
+        return getSS58AccountFromEthereumAccount(etheAddressHex);
+    }
+    if (pair.type === 'ecdsa') {
+        throw new Error('Ecdsa key type is not supported and it should be replaced with ethereum ones!');
+    }
+    return pair.address;
+}
+/**
+ * Returns ethereum style public key with suffixed 0xee example: 0x19a701d23f0ee1748b5d5f883cb833943096c6c4eeeeeeeeeeeeeeeeeeeeeeee
+ * @param pair
+ */
+function getUnifiedPublicKey(pair) {
+    if ('ethereum' === pair.type) {
+        const unifiedHex = getUnified32BytesAddress((0, util_1.u8aToHex)(pair.publicKey));
+        return (0, util_1.hexToU8a)(unifiedHex);
+    }
+    if (pair.type === 'ecdsa') {
+        throw new Error('Ecdsa key type is not supported and it should be replaced with ethereum ones!');
+    }
+    return pair.publicKey;
+}
+function reverseUnifiedAddressToEthereumAddress(unifiedAddress) {
+    if (!unifiedAddress.toLowerCase().endsWith('ee'.repeat(12))) {
+        throw new Error(`Address ${unifiedAddress} is not reversible!`);
+    }
+    return `${unifiedAddress.substring(0, 42)}`;
+}
+/**
+ * converts an ethereum account to SS58 format
+ * @param accountId20Hex
+ */
+function getSS58AccountFromEthereumAccount(accountId20Hex) {
+    const addressBytes = (0, util_1.hexToU8a)(accountId20Hex);
+    const suffix = new Uint8Array(12).fill(0xee);
+    const result = new Uint8Array(32);
+    result.set(addressBytes, 0);
+    result.set(suffix, 20);
+    return (0, util_crypto_1.encodeAddress)(result);
+}
+function getUnified32BytesAddress(ethAddressOrPublicKey) {
+    const ethAddressBytes = (0, util_1.hexToU8a)((0, util_crypto_1.ethereumEncode)(ethAddressOrPublicKey));
+    const suffix = new Uint8Array(12).fill(0xee);
+    const result = new Uint8Array(32);
+    result.set(ethAddressBytes, 0);
+    result.set(suffix, 20);
+    return (0, util_1.u8aToHex)(result);
+}

package/cjs/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const address = __importStar(require("./address"));
+const payloads = __importStar(require("./payloads"));
+const signature = __importStar(require("./signature"));
+const signatureDefinitions = __importStar(require("./signature.definitions"));
+__exportStar(require("./payloads"), exports);
+__exportStar(require("./signature"), exports);
+__exportStar(require("./signature.definitions"), exports);
+__exportStar(require("./address"), exports);
+exports.default = { ...payloads, ...address, ...signatureDefinitions, ...signature };

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/payloads.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/signature.definitions.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2 = exports.PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2 = exports.PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2 = exports.PASSKEY_PUBLIC_KEY_DEFINITION = exports.CLAIM_HANDLE_PAYLOAD_DEFINITION = exports.ADD_KEY_DATA_DEFINITION = exports.ADD_PROVIDER_DEFINITION = exports.EIP712_DOMAIN_DEFAULT = exports.EIP712_DOMAIN_DEFINITION = void 0;
+exports.EIP712_DOMAIN_DEFINITION = {
+    EIP712Domain: [
+        {
+            name: 'name',
+            type: 'string',
+        },
+        {
+            name: 'version',
+            type: 'string',
+        },
+        {
+            name: 'chainId',
+            type: 'uint256',
+        },
+        {
+            name: 'verifyingContract',
+            type: 'address',
+        },
+    ],
+};
+// using pallet_revive test chain ID for now.
+exports.EIP712_DOMAIN_DEFAULT = {
+    name: 'Frequency',
+    version: '1',
+    chainId: '0x190f1b44',
+    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+};
+exports.ADD_PROVIDER_DEFINITION = {
+    AddProvider: [
+        {
+            name: 'authorizedMsaId',
+            type: 'uint64',
+        },
+        {
+            name: 'schemaIds',
+            type: 'uint16[]',
+        },
+        {
+            name: 'expiration',
+            type: 'uint32',
+        },
+    ],
+};
+exports.ADD_KEY_DATA_DEFINITION = {
+    AddKeyData: [
+        {
+            name: 'msaId',
+            type: 'uint64',
+        },
+        {
+            name: 'expiration',
+            type: 'uint32',
+        },
+        {
+            name: 'newPublicKey',
+            type: 'address',
+        },
+    ],
+};
+exports.CLAIM_HANDLE_PAYLOAD_DEFINITION = {
+    ClaimHandlePayload: [
+        {
+            name: 'handle',
+            type: 'string',
+        },
+        {
+            name: 'expiration',
+            type: 'uint32',
+        },
+    ],
+};
+exports.PASSKEY_PUBLIC_KEY_DEFINITION = {
+    PasskeyPublicKey: [
+        {
+            name: 'publicKey',
+            type: 'bytes',
+        },
+    ],
+};
+exports.PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2 = {
+    PaginatedDeleteSignaturePayloadV2: [
+        {
+            name: 'schemaId',
+            type: 'uint16',
+        },
+        {
+            name: 'pageId',
+            type: 'uint16',
+        },
+        {
+            name: 'targetHash',
+            type: 'uint32',
+        },
+        {
+            name: 'expiration',
+            type: 'uint32',
+        },
+    ],
+};
+exports.PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2 = {
+    PaginatedUpsertSignaturePayloadV2: [
+        {
+            name: 'schemaId',
+            type: 'uint16',
+        },
+        {
+            name: 'pageId',
+            type: 'uint16',
+        },
+        {
+            name: 'targetHash',
+            type: 'uint32',
+        },
+        {
+            name: 'expiration',
+            type: 'uint32',
+        },
+        {
+            name: 'payload',
+            type: 'bytes',
+        },
+    ],
+};
+exports.ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2 = {
+    ItemizedSignaturePayloadV2: [
+        {
+            name: 'schemaId',
+            type: 'uint16',
+        },
+        {
+            name: 'targetHash',
+            type: 'uint32',
+        },
+        {
+            name: 'expiration',
+            type: 'uint32',
+        },
+        {
+            name: 'actions',
+            type: 'ItemAction[]',
+        },
+    ],
+    ItemAction: [
+        { name: 'actionType', type: 'string' },
+        { name: 'data', type: 'bytes' },
+        { name: 'index', type: 'uint16' },
+    ],
+};

package/cjs/signature.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signEip712 = signEip712;
+exports.verifyEip712Signature = verifyEip712Signature;
+exports.createAddKeyData = createAddKeyData;
+exports.createAddProvider = createAddProvider;
+exports.createClaimHandlePayload = createClaimHandlePayload;
+exports.createPasskeyPublicKey = createPasskeyPublicKey;
+exports.createItemizedAddAction = createItemizedAddAction;
+exports.createItemizedDeleteAction = createItemizedDeleteAction;
+exports.createItemizedSignaturePayloadV2 = createItemizedSignaturePayloadV2;
+exports.createPaginatedDeleteSignaturePayloadV2 = createPaginatedDeleteSignaturePayloadV2;
+exports.createPaginatedUpsertSignaturePayloadV2 = createPaginatedUpsertSignaturePayloadV2;
+exports.getEip712BrowserRequestAddKeyData = getEip712BrowserRequestAddKeyData;
+exports.getEip712BrowserRequestAddProvider = getEip712BrowserRequestAddProvider;
+exports.getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2 = getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2;
+exports.getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2 = getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2;
+exports.getEip712BrowserRequestItemizedSignaturePayloadV2 = getEip712BrowserRequestItemizedSignaturePayloadV2;
+exports.getEip712BrowserRequestClaimHandlePayload = getEip712BrowserRequestClaimHandlePayload;
+exports.getEip712BrowserRequestPasskeyPublicKey = getEip712BrowserRequestPasskeyPublicKey;
+const utils_1 = require("./utils");
+const address_1 = require("./address");
+const ethers_1 = require("ethers");
+const util_1 = require("@polkadot/util");
+const signature_definitions_1 = require("./signature.definitions");
+/**
+ * Signing EIP-712 compatible signature for payload
+ * @param secretKey
+ * @param payload
+ * @param chain
+ */
+async function signEip712(secretKey, payload, chain = 'Mainnet-Frequency') {
+    const types = getTypesFor(payload.type);
+    const normalizedPayload = normalizePayload(payload);
+    const wallet = new ethers_1.ethers.Wallet(secretKey);
+    // TODO: use correct chainID for different networks
+    // TODO: use correct contract address for different payloads
+    const signature = await wallet.signTypedData(signature_definitions_1.EIP712_DOMAIN_DEFAULT, types, normalizedPayload);
+    return { Ecdsa: signature };
+}
+/**
+ * Verify EIP-712 signatures
+ * @param ethereumAddress
+ * @param signature
+ * @param payload
+ * @param chain
+ */
+function verifyEip712Signature(ethereumAddress, signature, payload, chain = 'Mainnet-Frequency') {
+    const types = getTypesFor(payload.type);
+    const normalizedPayload = normalizePayload(payload);
+    // TODO: use correct chainID for different networks
+    // TODO: use correct contract address for different payloads
+    const recoveredAddress = ethers_1.ethers.verifyTypedData(signature_definitions_1.EIP712_DOMAIN_DEFAULT, types, normalizedPayload, signature);
+    return recoveredAddress.toLowerCase() === ethereumAddress.toLowerCase();
+}
+function normalizePayload(payload) {
+    const clonedPayload = Object.assign({}, payload);
+    switch (clonedPayload.type) {
+        case 'PaginatedUpsertSignaturePayloadV2':
+        case 'PaginatedDeleteSignaturePayloadV2':
+        case 'ItemizedSignaturePayloadV2':
+        case 'PasskeyPublicKey':
+        case 'ClaimHandlePayload':
+        case 'AddProvider':
+            break;
+        case 'AddKeyData':
+            // convert to 20 bytes ethereum address for signature
+            if (clonedPayload.newPublicKey.length !== 42) {
+                clonedPayload.newPublicKey = (0, address_1.reverseUnifiedAddressToEthereumAddress)(payload.newPublicKey);
+            }
+            clonedPayload.newPublicKey = clonedPayload.newPublicKey.toLowerCase();
+            break;
+        default:
+            throw new Error(`Unsupported payload type: ${JSON.stringify(payload)}`);
+    }
+    // Remove the type field
+    const { type, ...payloadWithoutType } = clonedPayload;
+    return payloadWithoutType;
+}
+function getTypesFor(payloadType) {
+    const PAYLOAD_TYPE_DEFINITIONS = {
+        PaginatedUpsertSignaturePayloadV2: signature_definitions_1.PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        PaginatedDeleteSignaturePayloadV2: signature_definitions_1.PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        ItemizedSignaturePayloadV2: signature_definitions_1.ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        PasskeyPublicKey: signature_definitions_1.PASSKEY_PUBLIC_KEY_DEFINITION,
+        ClaimHandlePayload: signature_definitions_1.CLAIM_HANDLE_PAYLOAD_DEFINITION,
+        AddKeyData: signature_definitions_1.ADD_KEY_DATA_DEFINITION,
+        AddProvider: signature_definitions_1.ADD_PROVIDER_DEFINITION,
+    };
+    const definition = PAYLOAD_TYPE_DEFINITIONS[payloadType];
+    if (!definition) {
+        throw new Error(`Unsupported payload type: ${payloadType}`);
+    }
+    return definition;
+}
+/**
+ * Build an AddKeyData payload for signature.
+ *
+ * @param msaId           MSA ID (uint64) to add the key
+ * @param newPublicKey    32 bytes public key to add in hex or Uint8Array
+ * @param expirationBlock Block number after which this payload is invalid
+ */
+function createAddKeyData(msaId, newPublicKey, expirationBlock) {
+    const parsedMsaId = typeof msaId === 'string' ? msaId : `${msaId}`;
+    const parsedNewPublicKey = typeof newPublicKey === 'object' ? (0, util_1.u8aToHex)(newPublicKey) : newPublicKey;
+    (0, utils_1.assert)((0, utils_1.isValidUint64String)(parsedMsaId), 'msaId should be a valid uint64');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    (0, utils_1.assert)((0, utils_1.isHexString)(parsedNewPublicKey), 'newPublicKey should be valid hex');
+    return {
+        type: 'AddKeyData',
+        msaId: parsedMsaId,
+        expiration: expirationBlock,
+        newPublicKey: parsedNewPublicKey,
+    };
+}
+/**
+ * Build an AddProvider payload for signature.
+ *
+ * @param authorizedMsaId MSA ID (uint64) that will be granted provider rights
+ * @param schemaIds       One or more schema IDs (uint16) the provider may use
+ * @param expirationBlock Block number after which this payload is invalid
+ */
+function createAddProvider(authorizedMsaId, schemaIds, expirationBlock) {
+    (0, utils_1.assert)((0, utils_1.isValidUint64String)(authorizedMsaId), 'authorizedMsaId should be a valid uint64');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    schemaIds.forEach((schemaId) => {
+        (0, utils_1.assert)((0, utils_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    });
+    return {
+        type: 'AddProvider',
+        authorizedMsaId: authorizedMsaId.toString(),
+        schemaIds,
+        expiration: expirationBlock,
+    };
+}
+/**
+ * Build a ClaimHandlePayload for signature.
+ *
+ * @param handle          The handle the user wishes to claim
+ * @param expirationBlock Block number after which this payload is invalid
+ */
+function createClaimHandlePayload(handle, expirationBlock) {
+    (0, utils_1.assert)(handle.length > 0, 'handle should be a valid string');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    return {
+        type: 'ClaimHandlePayload',
+        handle,
+        expiration: expirationBlock,
+    };
+}
+/**
+ * Build a PasskeyPublicKey payload for signature.
+ *
+ * @param publicKey The passkey’s public key (hex string or raw bytes)
+ */
+function createPasskeyPublicKey(publicKey) {
+    const parsedNewPublicKey = typeof publicKey === 'object' ? (0, util_1.u8aToHex)(publicKey) : publicKey;
+    (0, utils_1.assert)((0, utils_1.isHexString)(parsedNewPublicKey), 'publicKey should be valid hex');
+    return {
+        type: 'PasskeyPublicKey',
+        publicKey: parsedNewPublicKey,
+    };
+}
+function createItemizedAddAction(data) {
+    const parsedData = typeof data === 'object' ? (0, util_1.u8aToHex)(data) : data;
+    (0, utils_1.assert)((0, utils_1.isHexString)(parsedData), 'itemized data should be valid hex');
+    return { actionType: 'Add', data, index: 0 };
+}
+function createItemizedDeleteAction(index) {
+    (0, utils_1.assert)((0, utils_1.isValidUint16)(index), 'itemized index should be a valid uint16');
+    return { actionType: 'Delete', data: '0x', index };
+}
+/**
+ * Build an ItemizedSignaturePayloadV2 for signing.
+ *
+ * @param schemaId   uint16 schema identifier
+ * @param targetHash uint32 page hash
+ * @param expiration uint32 expiration block
+ * @param actions    Array of Add/Delete itemized actions
+ */
+function createItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions) {
+    (0, utils_1.assert)((0, utils_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(targetHash), 'targetHash should be a valid uint32');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(expiration), 'expiration should be a valid uint32');
+    (0, utils_1.assert)(actions.length > 0, 'At least one action is required for ItemizedSignaturePayloadV2');
+    return {
+        type: 'ItemizedSignaturePayloadV2',
+        schemaId,
+        targetHash,
+        expiration,
+        actions,
+    };
+}
+/**
+ * Build a PaginatedDeleteSignaturePayloadV2 for signing.
+ *
+ * @param schemaId   uint16 schema identifier
+ * @param pageId     uint16 page identifier
+ * @param targetHash uint32 page hash
+ * @param expiration uint32 expiration block
+ */
+function createPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration) {
+    (0, utils_1.assert)((0, utils_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    (0, utils_1.assert)((0, utils_1.isValidUint16)(pageId), 'pageId should be a valid uint16');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(targetHash), 'targetHash should be a valid uint32');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(expiration), 'expiration should be a valid uint32');
+    return {
+        type: 'PaginatedDeleteSignaturePayloadV2',
+        schemaId,
+        pageId,
+        targetHash,
+        expiration,
+    };
+}
+/**
+ * Build a PaginatedUpsertSignaturePayloadV2 for signing.
+ *
+ * @param schemaId   uint16 schema identifier
+ * @param pageId     uint16 page identifier
+ * @param targetHash uint32 page hash
+ * @param expiration uint32 expiration block
+ * @param payload    HexString or Uint8Array data to upsert
+ */
+function createPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload) {
+    const parsedPayload = typeof payload === 'object' ? (0, util_1.u8aToHex)(payload) : payload;
+    (0, utils_1.assert)((0, utils_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    (0, utils_1.assert)((0, utils_1.isValidUint16)(pageId), 'pageId should be a valid uint16');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(targetHash), 'targetHash should be a valid uint32');
+    (0, utils_1.assert)((0, utils_1.isValidUint32)(expiration), 'expiration should be a valid uint32');
+    (0, utils_1.assert)((0, utils_1.isHexString)(parsedPayload), 'payload should be valid hex');
+    return {
+        type: 'PaginatedUpsertSignaturePayloadV2',
+        schemaId,
+        pageId,
+        targetHash,
+        expiration,
+        payload: parsedPayload,
+    };
+}
+/**
+ * Returns the EIP-712 browser request for a AddKeyData for signing.
+ *
+ * @param msaId           MSA ID (uint64) to add the key
+ * @param newPublicKey    32 bytes public key to add in hex or Uint8Array
+ * @param expirationBlock Block number after which this payload is invalid
+ * @param domain
+ */
+function getEip712BrowserRequestAddKeyData(msaId, newPublicKey, expirationBlock, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createAddKeyData(msaId, newPublicKey, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.ADD_KEY_DATA_DEFINITION, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a AddProvider for signing.
+ *
+ * @param authorizedMsaId MSA ID (uint64) that will be granted provider rights
+ * @param schemaIds       One or more schema IDs (uint16) the provider may use
+ * @param expirationBlock Block number after which this payload is invalid
+ * @param domain
+ */
+function getEip712BrowserRequestAddProvider(authorizedMsaId, schemaIds, expirationBlock, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createAddProvider(authorizedMsaId, schemaIds, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.ADD_PROVIDER_DEFINITION, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a PaginatedUpsertSignaturePayloadV2 for signing.
+ *
+ * @param schemaId   uint16 schema identifier
+ * @param pageId     uint16 page identifier
+ * @param targetHash uint32 page hash
+ * @param expiration uint32 expiration block
+ * @param payload    HexString or Uint8Array data to upsert
+ * @param domain
+ */
+function getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a PaginatedDeleteSignaturePayloadV2 for signing.
+ *
+ * @param schemaId   uint16 schema identifier
+ * @param pageId     uint16 page identifier
+ * @param targetHash uint32 page hash
+ * @param expiration uint32 expiration block
+ * @param domain
+ */
+function getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a ItemizedSignaturePayloadV2 for signing.
+ *
+ * @param schemaId   uint16 schema identifier
+ * @param targetHash uint32 page hash
+ * @param expiration uint32 expiration block
+ * @param actions    Array of Add/Delete itemized actions
+ * @param domain
+ */
+function getEip712BrowserRequestItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a ClaimHandlePayload for signing.
+ *
+ * @param handle          The handle the user wishes to claim
+ * @param expirationBlock Block number after which this payload is invalid
+ * @param domain
+ */
+function getEip712BrowserRequestClaimHandlePayload(handle, expirationBlock, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createClaimHandlePayload(handle, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.CLAIM_HANDLE_PAYLOAD_DEFINITION, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a PasskeyPublicKey for signing.
+ *
+ * @param publicKey The passkey’s public key (hex string or raw bytes)
+ * @param domain
+ */
+function getEip712BrowserRequestPasskeyPublicKey(publicKey, domain = signature_definitions_1.EIP712_DOMAIN_DEFAULT) {
+    const message = createPasskeyPublicKey(publicKey);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_1.PASSKEY_PUBLIC_KEY_DEFINITION, message.type, domain, normalized);
+}
+function createEip712Payload(typeDefinition, primaryType, domain, message) {
+    return {
+        types: {
+            ...signature_definitions_1.EIP712_DOMAIN_DEFINITION,
+            ...typeDefinition,
+        },
+        primaryType,
+        domain,
+        message,
+    };
+}

package/cjs/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidUint16 = isValidUint16;
+exports.isValidUint32 = isValidUint32;
+exports.isValidUint64String = isValidUint64String;
+exports.isHexString = isHexString;
+exports.assert = assert;
+/**
+ * Validate that a number is a valid uint16 (0 to 65535)
+ */
+function isValidUint16(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 65535;
+}
+/**
+ * Validate that a number is a valid uint32 (0 to 4294967295)
+ */
+function isValidUint32(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+/**
+ * Validate that a number is a valid uint64 (0 to 18446744073709551615n)
+ */
+function isValidUint64String(value) {
+    const bigIntValue = typeof value === 'string' ? BigInt(value) : value;
+    return bigIntValue >= 0 && bigIntValue <= 18446744073709551615n;
+}
+/**
+ * Validate that a string is a valid hex string
+ */
+function isHexString(value) {
+    // Check if string starts with '0x' and contains only hex characters
+    const hexRegex = /^0[xX][0-9a-fA-F]*$/;
+    const isHex = hexRegex.test(value);
+    return isHex && value.length % 2 === 0;
+}
+/**
+ * Universal assert function
+ * @param condition
+ * @param message
+ */
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || ' Assertion failed');
+    }
+}