@frequency-chain/ethereum-utils 0.0.0-1220a2

package/cjs/signature.js

@@ -0,0 +1,555 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sign = sign;
+exports.verifySignature = verifySignature;
+exports.createAddKeyData = createAddKeyData;
+exports.createAuthorizedKeyData = createAuthorizedKeyData;
+exports.createAddProvider = createAddProvider;
+exports.createRecoveryCommitmentPayload = createRecoveryCommitmentPayload;
+exports.createClaimHandlePayload = createClaimHandlePayload;
+exports.createPasskeyPublicKey = createPasskeyPublicKey;
+exports.createItemizedAddAction = createItemizedAddAction;
+exports.createItemizedDeleteAction = createItemizedDeleteAction;
+exports.createItemizedSignaturePayloadV2 = createItemizedSignaturePayloadV2;
+exports.createPaginatedDeleteSignaturePayloadV2 = createPaginatedDeleteSignaturePayloadV2;
+exports.createPaginatedUpsertSignaturePayloadV2 = createPaginatedUpsertSignaturePayloadV2;
+exports.createSiwfSignedRequestPayload = createSiwfSignedRequestPayload;
+exports.createSiwfLoginRequestPayload = createSiwfLoginRequestPayload;
+exports.getEip712BrowserRequestAddKeyData = getEip712BrowserRequestAddKeyData;
+exports.getEip712BrowserRequestAuthorizedKeyData = getEip712BrowserRequestAuthorizedKeyData;
+exports.getEip712BrowserRequestAddProvider = getEip712BrowserRequestAddProvider;
+exports.getEip712BrowserRequestRecoveryCommitmentPayload = getEip712BrowserRequestRecoveryCommitmentPayload;
+exports.getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2 = getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2;
+exports.getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2 = getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2;
+exports.getEip712BrowserRequestItemizedSignaturePayloadV2 = getEip712BrowserRequestItemizedSignaturePayloadV2;
+exports.getEip712BrowserRequestClaimHandlePayload = getEip712BrowserRequestClaimHandlePayload;
+exports.getEip712BrowserRequestPasskeyPublicKey = getEip712BrowserRequestPasskeyPublicKey;
+exports.getEip712BrowserRequestSiwfSignedRequestPayload = getEip712BrowserRequestSiwfSignedRequestPayload;
+exports.getEthereumRegularSigner = getEthereumRegularSigner;
+exports.getEthereumMessageSigner = getEthereumMessageSigner;
+const utils_js_1 = require("./utils.js");
+const address_js_1 = require("./address.js");
+const ethers_1 = require("ethers");
+const util_1 = require("@polkadot/util");
+const signature_definitions_js_1 = require("./signature.definitions.js");
+/**
+ * Signing EIP-712 or ERC-191 compatible signature based on payload
+ * @param secretKey
+ * @param payload
+ * @param chain
+ */
+async function sign(secretKey, payload, chain) {
+    const signatureType = getSignatureType(payload.type);
+    const normalizedPayload = normalizePayload(payload);
+    const wallet = new ethers_1.ethers.Wallet(secretKey);
+    let signature;
+    switch (signatureType) {
+        case 'EIP-712':
+            // TODO: use correct contract address for different payloads
+            signature = await wallet.signTypedData(chain === 'Mainnet-Frequency' ? signature_definitions_js_1.EIP712_DOMAIN_MAINNET : signature_definitions_js_1.EIP712_DOMAIN_TESTNET, getTypesFor(payload.type), normalizedPayload);
+            break;
+        case 'EIP-191':
+            signature = await wallet.signMessage(payload.message);
+            break;
+        default:
+            throw new Error(`Unsupported signature type : ${signatureType}`);
+    }
+    return { Ecdsa: signature };
+}
+/**
+ * Verify EIP-712 and ERC-191 signatures based on payload
+ * @param ethereumAddress
+ * @param signature
+ * @param payload
+ * @param chain
+ */
+function verifySignature(ethereumAddress, signature, payload, chain) {
+    const signatureType = getSignatureType(payload.type);
+    const normalizedPayload = normalizePayload(payload);
+    let recoveredAddress;
+    switch (signatureType) {
+        case 'EIP-712':
+            // TODO: use correct contract address for different payloads
+            recoveredAddress = ethers_1.ethers.verifyTypedData(chain === 'Mainnet-Frequency' ? signature_definitions_js_1.EIP712_DOMAIN_MAINNET : signature_definitions_js_1.EIP712_DOMAIN_TESTNET, getTypesFor(payload.type), normalizedPayload, signature);
+            break;
+        case 'EIP-191':
+            recoveredAddress = ethers_1.ethers.verifyMessage(payload.message, signature);
+            break;
+        default:
+            throw new Error(`Unsupported signature type : ${signatureType}`);
+    }
+    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':
+        case 'RecoveryCommitmentPayload':
+        case 'SiwfLoginRequestPayload':
+            break;
+        case 'AddKeyData':
+            // convert to 20 bytes ethereum address for signature
+            if (clonedPayload.newPublicKey.length !== 42) {
+                clonedPayload.newPublicKey = (0, address_js_1.reverseUnifiedAddressToEthereumAddress)(payload.newPublicKey);
+            }
+            clonedPayload.newPublicKey = clonedPayload.newPublicKey.toLowerCase();
+            break;
+        case 'AuthorizedKeyData':
+            // convert to 20 bytes ethereum address for signature
+            if (clonedPayload.authorizedPublicKey.length !== 42) {
+                clonedPayload.authorizedPublicKey = (0, address_js_1.reverseUnifiedAddressToEthereumAddress)(payload.authorizedPublicKey);
+            }
+            clonedPayload.authorizedPublicKey = clonedPayload.authorizedPublicKey.toLowerCase();
+            break;
+        case 'SiwfSignedRequestPayload':
+            if (clonedPayload.userIdentifierAdminUrl == null) {
+                clonedPayload.userIdentifierAdminUrl = '';
+            }
+            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_js_1.PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        PaginatedDeleteSignaturePayloadV2: signature_definitions_js_1.PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        ItemizedSignaturePayloadV2: signature_definitions_js_1.ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        PasskeyPublicKey: signature_definitions_js_1.PASSKEY_PUBLIC_KEY_DEFINITION,
+        ClaimHandlePayload: signature_definitions_js_1.CLAIM_HANDLE_PAYLOAD_DEFINITION,
+        AddKeyData: signature_definitions_js_1.ADD_KEY_DATA_DEFINITION,
+        AuthorizedKeyData: signature_definitions_js_1.AUTHORIZED_KEY_DATA_DEFINITION,
+        AddProvider: signature_definitions_js_1.ADD_PROVIDER_DEFINITION,
+        RecoveryCommitmentPayload: signature_definitions_js_1.RECOVERY_COMMITMENT_PAYLOAD_DEFINITION,
+        // offchain signatures
+        SiwfSignedRequestPayload: signature_definitions_js_1.SIWF_SIGNED_REQUEST_PAYLOAD_DEFINITION,
+    };
+    const definition = PAYLOAD_TYPE_DEFINITIONS[payloadType];
+    if (!definition) {
+        throw new Error(`Unsupported payload type: ${payloadType}`);
+    }
+    return definition;
+}
+function getSignatureType(payloadType) {
+    if (payloadType === 'SiwfLoginRequestPayload') {
+        return 'EIP-191';
+    }
+    return 'EIP-712';
+}
+/**
+ * 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_js_1.assert)((0, utils_js_1.isValidUint64String)(parsedMsaId), 'msaId should be a valid uint64');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    (0, utils_js_1.assert)((0, utils_js_1.isHexString)(parsedNewPublicKey), 'newPublicKey should be valid hex');
+    return {
+        type: 'AddKeyData',
+        msaId: parsedMsaId,
+        expiration: expirationBlock,
+        newPublicKey: parsedNewPublicKey,
+    };
+}
+/**
+ * Build an AuthorizedKeyData payload for signature.
+ *
+ * @param msaId                  MSA ID (uint64) to add the key
+ * @param authorizedPublicKey    32 bytes public key to authorize in hex or Uint8Array
+ * @param expirationBlock        Block number after which this payload is invalid
+ */
+function createAuthorizedKeyData(msaId, newPublicKey, expirationBlock) {
+    const parsedMsaId = typeof msaId === 'string' ? msaId : `${msaId}`;
+    const parsedNewPublicKey = typeof newPublicKey === 'object' ? (0, util_1.u8aToHex)(newPublicKey) : newPublicKey;
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint64String)(parsedMsaId), 'msaId should be a valid uint64');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    (0, utils_js_1.assert)((0, utils_js_1.isHexString)(parsedNewPublicKey), 'newPublicKey should be valid hex');
+    return {
+        type: 'AuthorizedKeyData',
+        msaId: parsedMsaId,
+        expiration: expirationBlock,
+        authorizedPublicKey: 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_js_1.assert)((0, utils_js_1.isValidUint64String)(authorizedMsaId), 'authorizedMsaId should be a valid uint64');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    schemaIds.forEach((schemaId) => {
+        (0, utils_js_1.assert)((0, utils_js_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    });
+    return {
+        type: 'AddProvider',
+        authorizedMsaId: authorizedMsaId.toString(),
+        schemaIds,
+        expiration: expirationBlock,
+    };
+}
+/**
+ * Build a RecoveryCommitmentPayload for signature.
+ *
+ * @param recoveryCommitment The recovery commitment data as a HexString
+ * @param expirationBlock Block number after which this payload is invalid
+ */
+function createRecoveryCommitmentPayload(recoveryCommitment, expirationBlock) {
+    (0, utils_js_1.assert)((0, utils_js_1.isHexString)(recoveryCommitment), 'recoveryCommitment should be a valid hex string');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(expirationBlock), 'expiration should be a valid uint32');
+    return {
+        type: 'RecoveryCommitmentPayload',
+        recoveryCommitment: recoveryCommitment,
+        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_js_1.assert)(handle.length > 0, 'handle should be a valid string');
+    (0, utils_js_1.assert)((0, utils_js_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_js_1.assert)((0, utils_js_1.isHexString)(parsedNewPublicKey), 'publicKey should be valid hex');
+    return {
+        type: 'PasskeyPublicKey',
+        publicKey: parsedNewPublicKey,
+    };
+}
+/**
+ * Build AddAction payload for Itemized storage.
+ *
+ * @param data The data to be persisted on the Frequency chain
+ */
+function createItemizedAddAction(data) {
+    const parsedData = typeof data === 'object' ? (0, util_1.u8aToHex)(data) : data;
+    (0, utils_js_1.assert)((0, utils_js_1.isHexString)(parsedData), 'itemized data should be valid hex');
+    // since Metamask does not support union types, we have to include all fields and have to set the `index` value to zero
+    // even though it is not used for Add action
+    return { actionType: 'Add', data, index: 0 };
+}
+/**
+ * Build DeleteAction payload for Itemized storage.
+ *
+ * @param index The index of the item that we want to remove from the Frequency chain
+ */
+function createItemizedDeleteAction(index) {
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint16)(index), 'itemized index should be a valid uint16');
+    // since Metamask does not support union types, we have to include all fields and have to set the `data` value to 0x
+    // even though it is not used for Delete action
+    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_js_1.assert)((0, utils_js_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(targetHash), 'targetHash should be a valid uint32');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(expiration), 'expiration should be a valid uint32');
+    (0, utils_js_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_js_1.assert)((0, utils_js_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint16)(pageId), 'pageId should be a valid uint16');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(targetHash), 'targetHash should be a valid uint32');
+    (0, utils_js_1.assert)((0, utils_js_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_js_1.assert)((0, utils_js_1.isValidUint16)(schemaId), 'schemaId should be a valid uint16');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint16)(pageId), 'pageId should be a valid uint16');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(targetHash), 'targetHash should be a valid uint32');
+    (0, utils_js_1.assert)((0, utils_js_1.isValidUint32)(expiration), 'expiration should be a valid uint32');
+    (0, utils_js_1.assert)((0, utils_js_1.isHexString)(parsedPayload), 'payload should be valid hex');
+    return {
+        type: 'PaginatedUpsertSignaturePayloadV2',
+        schemaId,
+        pageId,
+        targetHash,
+        expiration,
+        payload: parsedPayload,
+    };
+}
+/**
+ * Build an SiwfSignedRequestPayload payload for signature.
+ *
+ * @param callback        Callback URL for login
+ * @param permissions       One or more schema IDs (uint16) the provider may use
+ * @param userIdentifierAdminUrl Only used for custom integration situations.
+ */
+function createSiwfSignedRequestPayload(callback, permissions, userIdentifierAdminUrl) {
+    permissions.forEach((schemaId) => {
+        (0, utils_js_1.assert)((0, utils_js_1.isValidUint16)(schemaId), 'permission should be a valid uint16');
+    });
+    return {
+        type: 'SiwfSignedRequestPayload',
+        callback: callback,
+        permissions,
+        userIdentifierAdminUrl,
+    };
+}
+/**
+ * Build an SiwfLoginRequestPayload payload for signature.
+ *
+ * @param message        login message
+ */
+function createSiwfLoginRequestPayload(message) {
+    return {
+        type: 'SiwfLoginRequestPayload',
+        message,
+    };
+}
+/**
+ * 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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createAddKeyData(msaId, newPublicKey, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_1.ADD_KEY_DATA_DEFINITION, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a AuthorizedKeyData for signing.
+ *
+ * @param msaId           MSA ID (uint64) to add the key
+ * @param authorizedPublicKey    32 bytes public key to add in hex or Uint8Array
+ * @param expirationBlock Block number after which this payload is invalid
+ * @param domain
+ */
+function getEip712BrowserRequestAuthorizedKeyData(msaId, authorizedPublicKey, expirationBlock, domain = signature_definitions_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createAuthorizedKeyData(msaId, authorizedPublicKey, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_1.AUTHORIZED_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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createAddProvider(authorizedMsaId, schemaIds, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_1.ADD_PROVIDER_DEFINITION, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a RecoveryCommitmentPayload for signing.
+ *
+ * @param recoveryCommitment The recovery commitment data as a Uint8Array
+ * @param expirationBlock Block number after which this payload is invalid
+ * @param domain
+ */
+function getEip712BrowserRequestRecoveryCommitmentPayload(recoveryCommitment, expirationBlock, domain = signature_definitions_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createRecoveryCommitmentPayload(recoveryCommitment, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_1.RECOVERY_COMMITMENT_PAYLOAD_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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createClaimHandlePayload(handle, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_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_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createPasskeyPublicKey(publicKey);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_1.PASSKEY_PUBLIC_KEY_DEFINITION, message.type, domain, normalized);
+}
+/**
+ * Returns the EIP-712 browser request for a SiwfSignedRequestPayload for signing.
+ *
+ * @param callback        Callback URL for login
+ * @param permissions       One or more schema IDs (uint16) the provider may use
+ * @param userIdentifierAdminUrl Only used for custom integration situations.
+ * @param domain
+ */
+function getEip712BrowserRequestSiwfSignedRequestPayload(callback, permissions, userIdentifierAdminUrl, domain = signature_definitions_js_1.EIP712_DOMAIN_MAINNET) {
+    const message = createSiwfSignedRequestPayload(callback, permissions, userIdentifierAdminUrl);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(signature_definitions_js_1.SIWF_SIGNED_REQUEST_PAYLOAD_DEFINITION, message.type, domain, normalized);
+}
+function createEip712Payload(typeDefinition, primaryType, domain, message) {
+    return {
+        types: {
+            ...signature_definitions_js_1.EIP712_DOMAIN_DEFINITION,
+            ...typeDefinition,
+        },
+        primaryType,
+        domain,
+        message,
+    };
+}
+/**
+ * Returns An ethereum compatible signature for the extrinsic
+ * @param ethereumPair
+ */
+function getEthereumRegularSigner(ethereumPair) {
+    return {
+        signRaw: async (payload) => {
+            const sig = ethereumPair.sign(payload.data);
+            const prefixedSignature = new Uint8Array(sig.length + 1);
+            prefixedSignature[0] = 2;
+            prefixedSignature.set(sig, 1);
+            const hex = (0, util_1.u8aToHex)(prefixedSignature);
+            return {
+                signature: hex,
+            };
+        },
+    };
+}
+/**
+ * This custom signer can get used to mimic EIP-191 message signing. By replacing the `ethereumPair.sign` with
+ * any wallet call we can sign any extrinsic with any wallet
+ * @param ethereumPair
+ */
+function getEthereumMessageSigner(ethereumPair) {
+    return {
+        signRaw: async (payload) => {
+            const sig = ethereumPair.sign(prefixEthereumTags(payload.data));
+            const prefixedSignature = new Uint8Array(sig.length + 1);
+            prefixedSignature[0] = 2;
+            prefixedSignature.set(sig, 1);
+            const hex = (0, util_1.u8aToHex)(prefixedSignature);
+            return {
+                signature: hex,
+            };
+        },
+    };
+}
+/**
+ * prefixing with the EIP-191 for personal_sign messages (this gets wrapped automatically in Metamask)
+ * @param hexPayload
+ */
+function prefixEthereumTags(hexPayload) {
+    const wrapped = `\x19Ethereum Signed Message:\n${hexPayload.length}${hexPayload}`;
+    const buffer = Buffer.from(wrapped, 'utf-8');
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+}

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');
+    }
+}