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

package/esm/signature.js

@@ -0,0 +1,526 @@
+import { assert, isHexString, isValidUint16, isValidUint32, isValidUint64String } from './utils.js';
+import { reverseUnifiedAddressToEthereumAddress } from './address.js';
+import { ethers } from 'ethers';
+import { u8aToHex } from '@polkadot/util';
+import { ADD_KEY_DATA_DEFINITION, ADD_PROVIDER_DEFINITION, AUTHORIZED_KEY_DATA_DEFINITION, CLAIM_HANDLE_PAYLOAD_DEFINITION, EIP712_DOMAIN_MAINNET, EIP712_DOMAIN_DEFINITION, ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2, PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2, PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2, PASSKEY_PUBLIC_KEY_DEFINITION, SIWF_SIGNED_REQUEST_PAYLOAD_DEFINITION, EIP712_DOMAIN_TESTNET, RECOVERY_COMMITMENT_PAYLOAD_DEFINITION, } from './signature.definitions.js';
+/**
+ * Signing EIP-712 or ERC-191 compatible signature based on payload
+ * @param secretKey
+ * @param payload
+ * @param chain
+ */
+export async function sign(secretKey, payload, chain) {
+    const signatureType = getSignatureType(payload.type);
+    const normalizedPayload = normalizePayload(payload);
+    const wallet = new 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' ? EIP712_DOMAIN_MAINNET : 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
+ */
+export 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.verifyTypedData(chain === 'Mainnet-Frequency' ? EIP712_DOMAIN_MAINNET : EIP712_DOMAIN_TESTNET, getTypesFor(payload.type), normalizedPayload, signature);
+            break;
+        case 'EIP-191':
+            recoveredAddress = 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 = 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 = 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: PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        PaginatedDeleteSignaturePayloadV2: PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        ItemizedSignaturePayloadV2: ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2,
+        PasskeyPublicKey: PASSKEY_PUBLIC_KEY_DEFINITION,
+        ClaimHandlePayload: CLAIM_HANDLE_PAYLOAD_DEFINITION,
+        AddKeyData: ADD_KEY_DATA_DEFINITION,
+        AuthorizedKeyData: AUTHORIZED_KEY_DATA_DEFINITION,
+        AddProvider: ADD_PROVIDER_DEFINITION,
+        RecoveryCommitmentPayload: RECOVERY_COMMITMENT_PAYLOAD_DEFINITION,
+        // offchain signatures
+        SiwfSignedRequestPayload: 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
+ */
+export function createAddKeyData(msaId, newPublicKey, expirationBlock) {
+    const parsedMsaId = typeof msaId === 'string' ? msaId : `${msaId}`;
+    const parsedNewPublicKey = typeof newPublicKey === 'object' ? u8aToHex(newPublicKey) : newPublicKey;
+    assert(isValidUint64String(parsedMsaId), 'msaId should be a valid uint64');
+    assert(isValidUint32(expirationBlock), 'expiration should be a valid uint32');
+    assert(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
+ */
+export function createAuthorizedKeyData(msaId, newPublicKey, expirationBlock) {
+    const parsedMsaId = typeof msaId === 'string' ? msaId : `${msaId}`;
+    const parsedNewPublicKey = typeof newPublicKey === 'object' ? u8aToHex(newPublicKey) : newPublicKey;
+    assert(isValidUint64String(parsedMsaId), 'msaId should be a valid uint64');
+    assert(isValidUint32(expirationBlock), 'expiration should be a valid uint32');
+    assert(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
+ */
+export function createAddProvider(authorizedMsaId, schemaIds, expirationBlock) {
+    assert(isValidUint64String(authorizedMsaId), 'authorizedMsaId should be a valid uint64');
+    assert(isValidUint32(expirationBlock), 'expiration should be a valid uint32');
+    schemaIds.forEach((schemaId) => {
+        assert(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
+ */
+export function createRecoveryCommitmentPayload(recoveryCommitment, expirationBlock) {
+    assert(isHexString(recoveryCommitment), 'recoveryCommitment should be a valid hex string');
+    assert(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
+ */
+export function createClaimHandlePayload(handle, expirationBlock) {
+    assert(handle.length > 0, 'handle should be a valid string');
+    assert(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)
+ */
+export function createPasskeyPublicKey(publicKey) {
+    const parsedNewPublicKey = typeof publicKey === 'object' ? u8aToHex(publicKey) : publicKey;
+    assert(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
+ */
+export function createItemizedAddAction(data) {
+    const parsedData = typeof data === 'object' ? u8aToHex(data) : data;
+    assert(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
+ */
+export function createItemizedDeleteAction(index) {
+    assert(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
+ */
+export function createItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions) {
+    assert(isValidUint16(schemaId), 'schemaId should be a valid uint16');
+    assert(isValidUint32(targetHash), 'targetHash should be a valid uint32');
+    assert(isValidUint32(expiration), 'expiration should be a valid uint32');
+    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
+ */
+export function createPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration) {
+    assert(isValidUint16(schemaId), 'schemaId should be a valid uint16');
+    assert(isValidUint16(pageId), 'pageId should be a valid uint16');
+    assert(isValidUint32(targetHash), 'targetHash should be a valid uint32');
+    assert(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
+ */
+export function createPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload) {
+    const parsedPayload = typeof payload === 'object' ? u8aToHex(payload) : payload;
+    assert(isValidUint16(schemaId), 'schemaId should be a valid uint16');
+    assert(isValidUint16(pageId), 'pageId should be a valid uint16');
+    assert(isValidUint32(targetHash), 'targetHash should be a valid uint32');
+    assert(isValidUint32(expiration), 'expiration should be a valid uint32');
+    assert(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.
+ */
+export function createSiwfSignedRequestPayload(callback, permissions, userIdentifierAdminUrl) {
+    permissions.forEach((schemaId) => {
+        assert(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
+ */
+export 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
+ */
+export function getEip712BrowserRequestAddKeyData(msaId, newPublicKey, expirationBlock, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createAddKeyData(msaId, newPublicKey, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestAuthorizedKeyData(msaId, authorizedPublicKey, expirationBlock, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createAuthorizedKeyData(msaId, authorizedPublicKey, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestAddProvider(authorizedMsaId, schemaIds, expirationBlock, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createAddProvider(authorizedMsaId, schemaIds, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestRecoveryCommitmentPayload(recoveryCommitment, expirationBlock, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createRecoveryCommitmentPayload(recoveryCommitment, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createPaginatedUpsertSignaturePayloadV2(schemaId, pageId, targetHash, expiration, payload);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createPaginatedDeleteSignaturePayloadV2(schemaId, pageId, targetHash, expiration);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createItemizedSignaturePayloadV2(schemaId, targetHash, expiration, actions);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestClaimHandlePayload(handle, expirationBlock, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createClaimHandlePayload(handle, expirationBlock);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestPasskeyPublicKey(publicKey, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createPasskeyPublicKey(publicKey);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(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
+ */
+export function getEip712BrowserRequestSiwfSignedRequestPayload(callback, permissions, userIdentifierAdminUrl, domain = EIP712_DOMAIN_MAINNET) {
+    const message = createSiwfSignedRequestPayload(callback, permissions, userIdentifierAdminUrl);
+    const normalized = normalizePayload(message);
+    return createEip712Payload(SIWF_SIGNED_REQUEST_PAYLOAD_DEFINITION, message.type, domain, normalized);
+}
+function createEip712Payload(typeDefinition, primaryType, domain, message) {
+    return {
+        types: {
+            ...EIP712_DOMAIN_DEFINITION,
+            ...typeDefinition,
+        },
+        primaryType,
+        domain,
+        message,
+    };
+}
+/**
+ * Returns An ethereum compatible signature for the extrinsic
+ * @param ethereumPair
+ */
+export 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 = 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
+ */
+export 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 = 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/esm/utils.js

@@ -0,0 +1,38 @@
+/**
+ * Validate that a number is a valid uint16 (0 to 65535)
+ */
+export function isValidUint16(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 65535;
+}
+/**
+ * Validate that a number is a valid uint32 (0 to 4294967295)
+ */
+export function isValidUint32(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+/**
+ * Validate that a number is a valid uint64 (0 to 18446744073709551615n)
+ */
+export 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
+ */
+export 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
+ */
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || ' Assertion failed');
+    }
+}

package/index.d.ts

@@ -0,0 +1,115 @@
+import * as payloads from './payloads.js';
+export * from './payloads.js';
+export * from './signature.js';
+export * from './signature.definitions.js';
+export * from './address.js';
+declare const _default: {
+    sign(secretKey: payloads.HexString, payload: payloads.SupportedPayload, chain: payloads.ChainType): Promise<payloads.EcdsaSignature>;
+    verifySignature(ethereumAddress: payloads.HexString, signature: payloads.HexString, payload: payloads.SupportedPayload, chain: payloads.ChainType): boolean;
+    createAddKeyData(msaId: string | bigint, newPublicKey: payloads.HexString | Uint8Array, expirationBlock: number): payloads.AddKeyData;
+    createAuthorizedKeyData(msaId: string | bigint, newPublicKey: payloads.HexString | Uint8Array, expirationBlock: number): payloads.AuthorizedKeyData;
+    createAddProvider(authorizedMsaId: string | bigint, schemaIds: number[], expirationBlock: number): payloads.AddProvider;
+    createRecoveryCommitmentPayload(recoveryCommitment: payloads.HexString, expirationBlock: number): payloads.RecoveryCommitmentPayload;
+    createClaimHandlePayload(handle: string, expirationBlock: number): payloads.ClaimHandlePayload;
+    createPasskeyPublicKey(publicKey: payloads.HexString | Uint8Array): payloads.PasskeyPublicKey;
+    createItemizedAddAction(data: payloads.HexString | Uint8Array): payloads.AddItemizedAction;
+    createItemizedDeleteAction(index: number): payloads.DeleteItemizedAction;
+    createItemizedSignaturePayloadV2(schemaId: number, targetHash: number, expiration: number, actions: payloads.ItemizedAction[]): payloads.ItemizedSignaturePayloadV2;
+    createPaginatedDeleteSignaturePayloadV2(schemaId: number, pageId: number, targetHash: number, expiration: number): payloads.PaginatedDeleteSignaturePayloadV2;
+    createPaginatedUpsertSignaturePayloadV2(schemaId: number, pageId: number, targetHash: number, expiration: number, payload: payloads.HexString | Uint8Array): payloads.PaginatedUpsertSignaturePayloadV2;
+    createSiwfSignedRequestPayload(callback: string, permissions: number[], userIdentifierAdminUrl?: string): payloads.SiwfSignedRequestPayload;
+    createSiwfLoginRequestPayload(message: string): payloads.SiwfLoginRequestPayload;
+    getEip712BrowserRequestAddKeyData(msaId: string | bigint, newPublicKey: payloads.HexString | Uint8Array, expirationBlock: number, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestAuthorizedKeyData(msaId: string | bigint, authorizedPublicKey: payloads.HexString | Uint8Array, expirationBlock: number, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestAddProvider(authorizedMsaId: string | bigint, schemaIds: number[], expirationBlock: number, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestRecoveryCommitmentPayload(recoveryCommitment: payloads.HexString, expirationBlock: number, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestPaginatedUpsertSignaturePayloadV2(schemaId: number, pageId: number, targetHash: number, expiration: number, payload: payloads.HexString | Uint8Array, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestPaginatedDeleteSignaturePayloadV2(schemaId: number, pageId: number, targetHash: number, expiration: number, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestItemizedSignaturePayloadV2(schemaId: number, targetHash: number, expiration: number, actions: payloads.ItemizedAction[], domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestClaimHandlePayload(handle: string, expirationBlock: number, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestPasskeyPublicKey(publicKey: payloads.HexString | Uint8Array, domain?: payloads.EipDomainPayload): unknown;
+    getEip712BrowserRequestSiwfSignedRequestPayload(callback: string, permissions: number[], userIdentifierAdminUrl?: string, domain?: payloads.EipDomainPayload): unknown;
+    getEthereumRegularSigner(ethereumPair: import("@polkadot/keyring/types.js").KeyringPair): import("@polkadot/types/types/extrinsic.js").Signer;
+    getEthereumMessageSigner(ethereumPair: import("@polkadot/keyring/types.js").KeyringPair): import("@polkadot/types/types/extrinsic.js").Signer;
+    EIP712_DOMAIN_DEFINITION: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+    };
+    EIP712_DOMAIN_MAINNET: payloads.EipDomainPayload;
+    EIP712_DOMAIN_TESTNET: payloads.EipDomainPayload;
+    ADD_PROVIDER_DEFINITION: {
+        AddProvider: {
+            name: string;
+            type: string;
+        }[];
+    };
+    ADD_KEY_DATA_DEFINITION: {
+        AddKeyData: {
+            name: string;
+            type: string;
+        }[];
+    };
+    AUTHORIZED_KEY_DATA_DEFINITION: {
+        AuthorizedKeyData: {
+            name: string;
+            type: string;
+        }[];
+    };
+    RECOVERY_COMMITMENT_PAYLOAD_DEFINITION: {
+        RecoveryCommitmentPayload: {
+            name: string;
+            type: string;
+        }[];
+    };
+    CLAIM_HANDLE_PAYLOAD_DEFINITION: {
+        ClaimHandlePayload: {
+            name: string;
+            type: string;
+        }[];
+    };
+    PASSKEY_PUBLIC_KEY_DEFINITION: {
+        PasskeyPublicKey: {
+            name: string;
+            type: string;
+        }[];
+    };
+    PAGINATED_DELETE_SIGNATURE_PAYLOAD_DEFINITION_V2: {
+        PaginatedDeleteSignaturePayloadV2: {
+            name: string;
+            type: string;
+        }[];
+    };
+    PAGINATED_UPSERT_SIGNATURE_PAYLOAD_DEFINITION_V2: {
+        PaginatedUpsertSignaturePayloadV2: {
+            name: string;
+            type: string;
+        }[];
+    };
+    ITEMIZED_SIGNATURE_PAYLOAD_DEFINITION_V2: {
+        ItemizedSignaturePayloadV2: {
+            name: string;
+            type: string;
+        }[];
+        ItemAction: {
+            name: string;
+            type: string;
+        }[];
+    };
+    SIWF_SIGNED_REQUEST_PAYLOAD_DEFINITION: {
+        SiwfSignedRequestPayload: {
+            name: string;
+            type: string;
+        }[];
+    };
+    createRandomKey(): payloads.EthereumKeyPair;
+    ethereumAddressToKeyringPair(ethereumAddress: import("@polkadot/types/interfaces/types.js").H160): import("@polkadot/keyring/types.js").KeyringPair;
+    getUnifiedAddress(pair: import("@polkadot/keyring/types.js").KeyringPair): string;
+    getUnifiedPublicKey(pair: import("@polkadot/keyring/types.js").KeyringPair): Uint8Array;
+    reverseUnifiedAddressToEthereumAddress(unifiedAddress: payloads.HexString): payloads.HexString;
+    getSS58AccountFromEthereumAccount(accountId20Hex: string): string;
+    getKeyringPairFromSecp256k1PrivateKey(secretKey: Uint8Array): import("@polkadot/keyring/types.js").KeyringPair;
+    getAccountId20MultiAddress(pair: import("@polkadot/keyring/types.js").KeyringPair): payloads.Address20MultiAddress;
+};
+export default _default;