@openfort/openfort-js 0.8.12 → 0.8.13

package/dist/index.cjs

@@ -4256,6 +4256,7 @@ class DeviceCredentialsManager {
     }
 }
 
+/* eslint-disable */
 const isBrowser = () => typeof document !== 'undefined';
 
 function base64URLEncode(str) {
@@ -4770,7 +4771,7 @@ class JsonRpcError extends Error {
     }
 }
 
-const buildOpenfortTransactions = async (transactionRequest, backendApiClients, account, authentication, policyId) => {
+const buildOpenfortTransactions$4 = async (transactionRequest, backendApiClients, account, authentication, policyId) => {
     const interactions = transactionRequest.map((tx) => {
         if (!tx.to) {
             throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
@@ -4801,7 +4802,7 @@ const buildOpenfortTransactions = async (transactionRequest, backendApiClients,
     return transactionResponse.data;
 };
 const sendTransaction = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
-    const openfortTransaction = await buildOpenfortTransactions(params, backendClient, account, authentication, policyId);
+    const openfortTransaction = await buildOpenfortTransactions$4(params, backendClient, account, authentication, policyId);
     let response;
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
@@ -5998,6 +5999,29 @@ const soneiumMinato = {
     slug: 'soneium-minato-testnet',
 };
 
+const sophonTestnet = {
+    name: 'Sophon Testnet',
+    title: 'Sophon Testnet',
+    chain: 'sophon-testnet',
+    rpc: ['https://rpc.testnet.sophon.xyz'],
+    nativeCurrency: {
+        name: 'Sophon',
+        symbol: 'SOPH',
+        decimals: 18,
+    },
+    shortName: 'sophon-testnet',
+    chainId: 531050104,
+    explorers: [
+        {
+            name: 'Sophon Block Explorer',
+            url: 'https://explorer.testnet.sophon.xyz',
+            standard: 'EIP3091',
+        },
+    ],
+    testnet: true,
+    slug: 'sophon-testnet',
+};
+
 const chainMap = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     56: chain$m,
@@ -6055,6 +6079,342 @@ const chainMap = {
     5611: opBNBTestnet,
     // eslint-disable-next-line @typescript-eslint/naming-convention
     1946: soneiumMinato,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    531050104: sophonTestnet,
+};
+
+const REQUIRED_CHAIN_PROPERTIES = ['chainId', 'chainName', 'nativeCurrency'];
+const isValidChainParameter = (chainParam) => (REQUIRED_CHAIN_PROPERTIES.every((key) => key in chainParam));
+const validateNativeCurrency = (nativeCurrency) => {
+    if (!nativeCurrency || typeof nativeCurrency !== 'object')
+        return false;
+    const hasRequiredProperties = ('name' in nativeCurrency
+        && 'symbol' in nativeCurrency
+        && 'decimals' in nativeCurrency);
+    if (!hasRequiredProperties)
+        return false;
+    return (typeof nativeCurrency.name === 'string'
+        && typeof nativeCurrency.symbol === 'string'
+        && typeof nativeCurrency.decimals === 'number'
+        && Number.isInteger(nativeCurrency.decimals));
+};
+const transformChainParameter = (chainParam) => {
+    if (!chainParam || typeof chainParam !== 'object') {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Invalid chain parameter: expected an object');
+    }
+    if (!isValidChainParameter(chainParam)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid chain parameter. The following properties are required: ${REQUIRED_CHAIN_PROPERTIES.join(', ')}`);
+    }
+    if (!chainParam.chainName || chainParam.chainName.trim() === '') {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'chainName cannot be empty');
+    }
+    if (!validateNativeCurrency(chainParam.nativeCurrency)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Invalid nativeCurrency object');
+    }
+    if (chainParam.rpcUrls?.length === 0) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'At least one RPC URL must be provided');
+    }
+    // Ensure chainId is a valid hex string
+    if (!/^0x[0-9a-fA-F]+$/.test(chainParam.chainId)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'chainId must be a valid hex string');
+    }
+    return {
+        chainId: chainParam.chainId,
+        blockExplorerUrls: chainParam.blockExplorerUrls || [],
+        chainName: chainParam.chainName,
+        iconUrls: chainParam.iconUrls || [],
+        rpcUrls: chainParam.rpcUrls || [],
+        nativeCurrency: chainParam.nativeCurrency,
+    };
+};
+const addEthereumChain = async ({ params, rpcProvider, }) => {
+    if (!params || !Array.isArray(params) || params.length === 0) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Invalid parameters for wallet_addEthereumChain');
+    }
+    const chainParameter = transformChainParameter(params[0]);
+    const chainIdNumber = parseInt(chainParameter.chainId, 16);
+    // Get current chainId
+    const { chainId: currentChainId } = await rpcProvider.detectNetwork();
+    // If we're already on this chain, return false
+    if (chainIdNumber === currentChainId) {
+        return false;
+    }
+    try {
+        const signer = await SignerManager.embedded();
+        if (!signer) {
+            throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - no account available');
+        }
+        // If we successfully configured the chain, return null (success)
+        return null;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to add chain: ${error.message}`);
+        }
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to add chain');
+    }
+};
+
+function formatPolicyData(policy) {
+    const data = (() => {
+        if (policy.type === 'token-allowance') {
+            return {
+                allowance: (policy.data.allowance.toString()),
+            };
+        }
+        if (policy.type === 'gas-limit') {
+            return {
+                limit: policy.data.limit.toString(),
+            };
+        }
+        return policy.data;
+    })();
+    return {
+        data,
+        type: typeof policy.type === 'string' ? policy.type : policy.type.custom,
+    };
+}
+function formatPermissionRequest(permission) {
+    return {
+        ...permission,
+        policies: permission.policies.map(formatPolicyData),
+        required: permission.required ?? false,
+        type: typeof permission.type === 'string'
+            ? permission.type
+            : permission.type.custom,
+    };
+}
+const formatSessionRequest$1 = (address, chainId, validAfter, validUntil, policyId, optimistic = false, whitelist, player, limit, externalOwnerAddress) => {
+    const request = {
+        address,
+        chainId,
+        validAfter,
+        validUntil,
+        optimistic,
+        whitelist,
+        player,
+    };
+    if (policyId)
+        request.policy = policyId;
+    if (externalOwnerAddress)
+        request.externalOwnerAddress = externalOwnerAddress;
+    if (limit)
+        request.limit = limit;
+    return request;
+};
+const buildOpenfortTransactions$3 = async (params, backendApiClients, account, authentication, policyId) => {
+    const param = params[0];
+    const now = Math.floor(new Date().getTime() / 1000);
+    const expiry = Math.floor(new Date(Date.now() + param.expiry * 1000).getTime() / 1000);
+    const formattedPermissions = param.permissions.map(formatPermissionRequest);
+    const whitelist = formattedPermissions.filter((p) => p.type === 'contract-call'
+        || p.type === 'erc20-token-transfer').map((p) => p.data.address);
+    if (param.signer && param.signer.type === 'keys') {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Failed to request permissions - missing session address');
+    }
+    const sessionAddress = param.signer?.data?.id;
+    if (!sessionAddress) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Failed to request permissions - missing session address');
+    }
+    const sessionRequest = formatSessionRequest$1(sessionAddress, account.chainId, now, expiry, policyId, false, whitelist, authentication.player);
+    const transactionResponse = await backendApiClients.sessionsApi.createSession({
+        createSessionRequest: sessionRequest,
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+function formatRequest(result) {
+    return {
+        expiry: result.validUntil ? Number(result.validUntil) : 0,
+        grantedPermissions: result.whitelist?.map((address) => ({
+            type: 'contract-call',
+            data: {
+                address,
+                calls: [],
+            },
+            policies: [{
+                    data: {
+                        limit: result.limit,
+                    },
+                    type: { custom: 'usage-limit' },
+                }],
+        })),
+        permissionsContext: result.id,
+    };
+}
+const registerSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions$3(params, backendClient, account, authentication, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.signableHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
+        const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
+            id: openfortTransaction.id,
+            signatureRequest: { signature },
+        });
+        if (!openfortSignatureResponse) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }
+        response = openfortSignatureResponse.data;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+    }
+    if (response.isActive === false) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
+    }
+    return formatRequest(response);
+};
+
+const formatSessionRequest = (address, chainId, player, policyId) => {
+    const request = {
+        address,
+        chainId,
+        player,
+    };
+    if (policyId)
+        request.policy = policyId;
+    return request;
+};
+const buildOpenfortTransactions$2 = async (params, backendApiClients, account, authentication, policyId) => {
+    const sessionRequest = formatSessionRequest(params.permissionContext, account.chainId, authentication.player, policyId);
+    const transactionResponse = await backendApiClients.sessionsApi.revokeSession({
+        revokeSessionRequest: sessionRequest,
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const revokeSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions$2(params, backendClient, account, authentication, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.signableHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
+        const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
+            id: openfortTransaction.id,
+            signatureRequest: { signature },
+        });
+        if (!openfortSignatureResponse) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }
+        response = openfortSignatureResponse.data;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+    }
+    if (response.isActive === false) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
+    }
+    return {};
+};
+
+const buildOpenfortTransactions$1 = async (calls, backendApiClients, account, authentication, policyId) => {
+    const interactions = calls.map((call) => {
+        if (!call.to) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'wallet_sendCalls requires a "to" field');
+        }
+        return {
+            to: String(call.to),
+            data: call.data ? String(call.data) : undefined,
+            value: call.value ? String(call.value) : undefined,
+        };
+    });
+    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
+        createTransactionIntentRequest: {
+            policy: policyId,
+            chainId: account.chainId,
+            interactions,
+        },
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const sendCalls = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions$1(params[0].calls, backendClient, account, authentication, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.signableHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
+        const openfortSignatureResponse = (await backendClient.transactionIntentsApi.signature({
+            id: openfortTransaction.id,
+            signatureRequest: { signature },
+        })).data.response;
+        if (!openfortSignatureResponse) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }
+        response = openfortSignatureResponse;
+    }
+    else if (openfortTransaction.response) {
+        response = openfortTransaction.response;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+    }
+    if (response.status === 0 && !response.transactionHash) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.error.reason);
+    }
+    return response.transactionHash;
+};
+
+const buildOpenfortTransactions = async (transactionIntentId, backendApiClients, authentication) => {
+    const transactionResponse = await backendApiClients.transactionIntentsApi.getTransactionIntent({
+        id: transactionIntentId,
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const getCallStatus = async ({ params, authentication, backendClient, }) => {
+    const transactionIntent = await buildOpenfortTransactions(params[0], backendClient, authentication);
+    return {
+        status: !transactionIntent.response ? 'PENDING' : 'CONFIRMED',
+        receipts: transactionIntent.response
+            ? [{
+                    status: transactionIntent.response.status === 0 ? 'reverted' : 'success',
+                    logs: transactionIntent.response.logs?.map((log) => ({
+                        address: log.address,
+                        data: log.data,
+                        topics: log.topics,
+                    })) || [],
+                    blockHash: transactionIntent.response.transactionHash || '',
+                    blockNumber: BigInt(transactionIntent.response.blockNumber || 0),
+                    gasUsed: BigInt(transactionIntent.response.gasUsed || 0),
+                    transactionHash: transactionIntent.response.transactionHash || '',
+                }]
+            : undefined,
+    };
 };
 
 class EvmProvider {
@@ -6089,7 +6449,10 @@ class EvmProvider {
     };
     async #performRequest(request) {
         switch (request.method) {
-            case 'eth_accounts':
+            case 'eth_accounts': {
+                const account = Account.fromStorage(this.#storage);
+                return account ? [account.address] : [];
+            }
             case 'eth_requestAccounts': {
                 let account = Account.fromStorage(this.#storage);
                 if (account) {
@@ -6148,6 +6511,96 @@ class EvmProvider {
                 const { chainId } = await this.#rpcProvider.detectNetwork();
                 return bytes.hexlify(chainId);
             }
+            case 'wallet_addEthereumChain': {
+                const signer = SignerManager.fromStorage();
+                if (!signer) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - must be authenticated and configured with a signer');
+                }
+                return await addEthereumChain({
+                    params: request.params || [],
+                    rpcProvider: this.#rpcProvider,
+                });
+            }
+            // EIP-5792: Wallet Call API
+            case 'wallet_showCallsStatus': {
+                return null;
+            }
+            case 'wallet_getCallsStatus': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await getCallStatus({
+                    params: (request.params || {}),
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                    account,
+                });
+            }
+            case 'wallet_sendCalls': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await sendCalls({
+                    params: request.params || [],
+                    signer,
+                    account,
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                    policyId: this.#policyId,
+                });
+            }
+            case 'wallet_grantPermissions': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await registerSession({
+                    params: (request.params || []),
+                    signer,
+                    account,
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                    policyId: this.#policyId,
+                });
+            }
+            // EIP-7715: Wallet Session Key API
+            case 'wallet_revokePermissions': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await revokeSession({
+                    params: (request.params || {}),
+                    signer,
+                    account,
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                });
+            }
+            case 'wallet_getCapabilities': {
+                const { chainId } = await this.#rpcProvider.detectNetwork();
+                const capabilities = {
+                    [bytes.hexlify(chainId)]: {
+                        permissions: {
+                            supported: true,
+                            signerTypes: ['account', 'key'],
+                            keyTypes: ['secp256k1'],
+                            permissionTypes: ['contract-calls'],
+                        },
+                    },
+                };
+                return capabilities;
+            }
             // Pass through methods
             case 'eth_gasPrice':
             case 'eth_getBalance':
@@ -6164,7 +6617,7 @@ class EvmProvider {
                 return this.#rpcProvider.send(request.method, request.params || []);
             }
             default: {
-                throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
+                throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, `${request.method}: Method not supported`);
             }
         }
     }
@@ -6308,7 +6761,7 @@ class Openfort {
      * @returns A Provider instance.
      * @throws {OpenfortError} If the signer is not an EmbeddedSigner.
      */
-    getEthereumProvider(options = { announceProvider: true }) {
+    getEthereumProvider(options = {}) {
         const authentication = Authentication.fromStorage(this.storage);
         const signer = SignerManager.fromStorage();
         const account = Account.fromStorage(this.storage);
@@ -6321,12 +6774,10 @@ class Openfort {
             backendApiClients: this.backendApiClients,
             policyId: options.policy,
         });
-        if (options?.announceProvider) {
-            announceProvider({
-                info: openfortProviderInfo,
-                provider,
-            });
-        }
+        announceProvider({
+            info: { ...openfortProviderInfo, ...options.providerInfo },
+            provider,
+        });
         return provider;
     }
     /**
@@ -6406,7 +6857,9 @@ class Openfort {
         // eslint-disable-next-line no-param-reassign
         delete types.EIP712Domain;
         const account = Account.fromStorage(this.storage);
-        if (account && account.type === AccountType.UPGRADEABLE_V5) {
+        if (account && [AccountType.UPGRADEABLE_V5,
+            AccountType.UPGRADEABLE_V6,
+            AccountType.ZKSYNC_UPGRADEABLE_V1].includes(account.type)) {
             const updatedDomain = {
                 name: 'Openfort',
                 version: '0.5',

package/dist/index.d.ts

@@ -589,8 +589,12 @@ declare class Openfort {
      * @throws {OpenfortError} If the signer is not an EmbeddedSigner.
      */
     getEthereumProvider(options?: {
-        announceProvider: boolean;
         policy?: string;
+        providerInfo?: {
+            icon: `data:image/${string}`;
+            name: string;
+            rdns: string;
+        };
     }): Provider;
     /**
      * Configures a session key and returns the session key details.

package/dist/index.js

@@ -4233,6 +4233,7 @@ class DeviceCredentialsManager {
     }
 }
 
+/* eslint-disable */
 const isBrowser = () => typeof document !== 'undefined';
 
 function base64URLEncode(str) {
@@ -4747,7 +4748,7 @@ class JsonRpcError extends Error {
     }
 }
 
-const buildOpenfortTransactions = async (transactionRequest, backendApiClients, account, authentication, policyId) => {
+const buildOpenfortTransactions$4 = async (transactionRequest, backendApiClients, account, authentication, policyId) => {
     const interactions = transactionRequest.map((tx) => {
         if (!tx.to) {
             throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
@@ -4778,7 +4779,7 @@ const buildOpenfortTransactions = async (transactionRequest, backendApiClients,
     return transactionResponse.data;
 };
 const sendTransaction = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
-    const openfortTransaction = await buildOpenfortTransactions(params, backendClient, account, authentication, policyId);
+    const openfortTransaction = await buildOpenfortTransactions$4(params, backendClient, account, authentication, policyId);
     let response;
     if (openfortTransaction?.nextAction?.payload?.signableHash) {
         const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
@@ -5975,6 +5976,29 @@ const soneiumMinato = {
     slug: 'soneium-minato-testnet',
 };
 
+const sophonTestnet = {
+    name: 'Sophon Testnet',
+    title: 'Sophon Testnet',
+    chain: 'sophon-testnet',
+    rpc: ['https://rpc.testnet.sophon.xyz'],
+    nativeCurrency: {
+        name: 'Sophon',
+        symbol: 'SOPH',
+        decimals: 18,
+    },
+    shortName: 'sophon-testnet',
+    chainId: 531050104,
+    explorers: [
+        {
+            name: 'Sophon Block Explorer',
+            url: 'https://explorer.testnet.sophon.xyz',
+            standard: 'EIP3091',
+        },
+    ],
+    testnet: true,
+    slug: 'sophon-testnet',
+};
+
 const chainMap = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     56: chain$m,
@@ -6032,6 +6056,342 @@ const chainMap = {
     5611: opBNBTestnet,
     // eslint-disable-next-line @typescript-eslint/naming-convention
     1946: soneiumMinato,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    531050104: sophonTestnet,
+};
+
+const REQUIRED_CHAIN_PROPERTIES = ['chainId', 'chainName', 'nativeCurrency'];
+const isValidChainParameter = (chainParam) => (REQUIRED_CHAIN_PROPERTIES.every((key) => key in chainParam));
+const validateNativeCurrency = (nativeCurrency) => {
+    if (!nativeCurrency || typeof nativeCurrency !== 'object')
+        return false;
+    const hasRequiredProperties = ('name' in nativeCurrency
+        && 'symbol' in nativeCurrency
+        && 'decimals' in nativeCurrency);
+    if (!hasRequiredProperties)
+        return false;
+    return (typeof nativeCurrency.name === 'string'
+        && typeof nativeCurrency.symbol === 'string'
+        && typeof nativeCurrency.decimals === 'number'
+        && Number.isInteger(nativeCurrency.decimals));
+};
+const transformChainParameter = (chainParam) => {
+    if (!chainParam || typeof chainParam !== 'object') {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Invalid chain parameter: expected an object');
+    }
+    if (!isValidChainParameter(chainParam)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid chain parameter. The following properties are required: ${REQUIRED_CHAIN_PROPERTIES.join(', ')}`);
+    }
+    if (!chainParam.chainName || chainParam.chainName.trim() === '') {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'chainName cannot be empty');
+    }
+    if (!validateNativeCurrency(chainParam.nativeCurrency)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Invalid nativeCurrency object');
+    }
+    if (chainParam.rpcUrls?.length === 0) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'At least one RPC URL must be provided');
+    }
+    // Ensure chainId is a valid hex string
+    if (!/^0x[0-9a-fA-F]+$/.test(chainParam.chainId)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'chainId must be a valid hex string');
+    }
+    return {
+        chainId: chainParam.chainId,
+        blockExplorerUrls: chainParam.blockExplorerUrls || [],
+        chainName: chainParam.chainName,
+        iconUrls: chainParam.iconUrls || [],
+        rpcUrls: chainParam.rpcUrls || [],
+        nativeCurrency: chainParam.nativeCurrency,
+    };
+};
+const addEthereumChain = async ({ params, rpcProvider, }) => {
+    if (!params || !Array.isArray(params) || params.length === 0) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Invalid parameters for wallet_addEthereumChain');
+    }
+    const chainParameter = transformChainParameter(params[0]);
+    const chainIdNumber = parseInt(chainParameter.chainId, 16);
+    // Get current chainId
+    const { chainId: currentChainId } = await rpcProvider.detectNetwork();
+    // If we're already on this chain, return false
+    if (chainIdNumber === currentChainId) {
+        return false;
+    }
+    try {
+        const signer = await SignerManager.embedded();
+        if (!signer) {
+            throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - no account available');
+        }
+        // If we successfully configured the chain, return null (success)
+        return null;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to add chain: ${error.message}`);
+        }
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to add chain');
+    }
+};
+
+function formatPolicyData(policy) {
+    const data = (() => {
+        if (policy.type === 'token-allowance') {
+            return {
+                allowance: (policy.data.allowance.toString()),
+            };
+        }
+        if (policy.type === 'gas-limit') {
+            return {
+                limit: policy.data.limit.toString(),
+            };
+        }
+        return policy.data;
+    })();
+    return {
+        data,
+        type: typeof policy.type === 'string' ? policy.type : policy.type.custom,
+    };
+}
+function formatPermissionRequest(permission) {
+    return {
+        ...permission,
+        policies: permission.policies.map(formatPolicyData),
+        required: permission.required ?? false,
+        type: typeof permission.type === 'string'
+            ? permission.type
+            : permission.type.custom,
+    };
+}
+const formatSessionRequest$1 = (address, chainId, validAfter, validUntil, policyId, optimistic = false, whitelist, player, limit, externalOwnerAddress) => {
+    const request = {
+        address,
+        chainId,
+        validAfter,
+        validUntil,
+        optimistic,
+        whitelist,
+        player,
+    };
+    if (policyId)
+        request.policy = policyId;
+    if (externalOwnerAddress)
+        request.externalOwnerAddress = externalOwnerAddress;
+    if (limit)
+        request.limit = limit;
+    return request;
+};
+const buildOpenfortTransactions$3 = async (params, backendApiClients, account, authentication, policyId) => {
+    const param = params[0];
+    const now = Math.floor(new Date().getTime() / 1000);
+    const expiry = Math.floor(new Date(Date.now() + param.expiry * 1000).getTime() / 1000);
+    const formattedPermissions = param.permissions.map(formatPermissionRequest);
+    const whitelist = formattedPermissions.filter((p) => p.type === 'contract-call'
+        || p.type === 'erc20-token-transfer').map((p) => p.data.address);
+    if (param.signer && param.signer.type === 'keys') {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Failed to request permissions - missing session address');
+    }
+    const sessionAddress = param.signer?.data?.id;
+    if (!sessionAddress) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'Failed to request permissions - missing session address');
+    }
+    const sessionRequest = formatSessionRequest$1(sessionAddress, account.chainId, now, expiry, policyId, false, whitelist, authentication.player);
+    const transactionResponse = await backendApiClients.sessionsApi.createSession({
+        createSessionRequest: sessionRequest,
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+function formatRequest(result) {
+    return {
+        expiry: result.validUntil ? Number(result.validUntil) : 0,
+        grantedPermissions: result.whitelist?.map((address) => ({
+            type: 'contract-call',
+            data: {
+                address,
+                calls: [],
+            },
+            policies: [{
+                    data: {
+                        limit: result.limit,
+                    },
+                    type: { custom: 'usage-limit' },
+                }],
+        })),
+        permissionsContext: result.id,
+    };
+}
+const registerSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions$3(params, backendClient, account, authentication, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.signableHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
+        const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
+            id: openfortTransaction.id,
+            signatureRequest: { signature },
+        });
+        if (!openfortSignatureResponse) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }
+        response = openfortSignatureResponse.data;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+    }
+    if (response.isActive === false) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
+    }
+    return formatRequest(response);
+};
+
+const formatSessionRequest = (address, chainId, player, policyId) => {
+    const request = {
+        address,
+        chainId,
+        player,
+    };
+    if (policyId)
+        request.policy = policyId;
+    return request;
+};
+const buildOpenfortTransactions$2 = async (params, backendApiClients, account, authentication, policyId) => {
+    const sessionRequest = formatSessionRequest(params.permissionContext, account.chainId, authentication.player, policyId);
+    const transactionResponse = await backendApiClients.sessionsApi.revokeSession({
+        revokeSessionRequest: sessionRequest,
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const revokeSession = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions$2(params, backendClient, account, authentication, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.signableHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
+        const openfortSignatureResponse = await backendClient.sessionsApi.signatureSession({
+            id: openfortTransaction.id,
+            signatureRequest: { signature },
+        });
+        if (!openfortSignatureResponse) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }
+        response = openfortSignatureResponse.data;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+    }
+    if (response.isActive === false) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Failed to request permissions');
+    }
+    return {};
+};
+
+const buildOpenfortTransactions$1 = async (calls, backendApiClients, account, authentication, policyId) => {
+    const interactions = calls.map((call) => {
+        if (!call.to) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'wallet_sendCalls requires a "to" field');
+        }
+        return {
+            to: String(call.to),
+            data: call.data ? String(call.data) : undefined,
+            value: call.value ? String(call.value) : undefined,
+        };
+    });
+    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
+        createTransactionIntentRequest: {
+            policy: policyId,
+            chainId: account.chainId,
+            interactions,
+        },
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const sendCalls = async ({ params, signer, account, authentication, backendClient, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions$1(params[0].calls, backendClient, account, authentication, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.signableHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.signableHash);
+        const openfortSignatureResponse = (await backendClient.transactionIntentsApi.signature({
+            id: openfortTransaction.id,
+            signatureRequest: { signature },
+        })).data.response;
+        if (!openfortSignatureResponse) {
+            throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+        }
+        response = openfortSignatureResponse;
+    }
+    else if (openfortTransaction.response) {
+        response = openfortTransaction.response;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'Transaction failed to submit');
+    }
+    if (response.status === 0 && !response.transactionHash) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, response.error.reason);
+    }
+    return response.transactionHash;
+};
+
+const buildOpenfortTransactions = async (transactionIntentId, backendApiClients, authentication) => {
+    const transactionResponse = await backendApiClients.transactionIntentsApi.getTransactionIntent({
+        id: transactionIntentId,
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': authentication.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': authentication.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': authentication.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const getCallStatus = async ({ params, authentication, backendClient, }) => {
+    const transactionIntent = await buildOpenfortTransactions(params[0], backendClient, authentication);
+    return {
+        status: !transactionIntent.response ? 'PENDING' : 'CONFIRMED',
+        receipts: transactionIntent.response
+            ? [{
+                    status: transactionIntent.response.status === 0 ? 'reverted' : 'success',
+                    logs: transactionIntent.response.logs?.map((log) => ({
+                        address: log.address,
+                        data: log.data,
+                        topics: log.topics,
+                    })) || [],
+                    blockHash: transactionIntent.response.transactionHash || '',
+                    blockNumber: BigInt(transactionIntent.response.blockNumber || 0),
+                    gasUsed: BigInt(transactionIntent.response.gasUsed || 0),
+                    transactionHash: transactionIntent.response.transactionHash || '',
+                }]
+            : undefined,
+    };
 };
 
 class EvmProvider {
@@ -6066,7 +6426,10 @@ class EvmProvider {
     };
     async #performRequest(request) {
         switch (request.method) {
-            case 'eth_accounts':
+            case 'eth_accounts': {
+                const account = Account.fromStorage(this.#storage);
+                return account ? [account.address] : [];
+            }
             case 'eth_requestAccounts': {
                 let account = Account.fromStorage(this.#storage);
                 if (account) {
@@ -6125,6 +6488,96 @@ class EvmProvider {
                 const { chainId } = await this.#rpcProvider.detectNetwork();
                 return hexlify(chainId);
             }
+            case 'wallet_addEthereumChain': {
+                const signer = SignerManager.fromStorage();
+                if (!signer) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - must be authenticated and configured with a signer');
+                }
+                return await addEthereumChain({
+                    params: request.params || [],
+                    rpcProvider: this.#rpcProvider,
+                });
+            }
+            // EIP-5792: Wallet Call API
+            case 'wallet_showCallsStatus': {
+                return null;
+            }
+            case 'wallet_getCallsStatus': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await getCallStatus({
+                    params: (request.params || {}),
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                    account,
+                });
+            }
+            case 'wallet_sendCalls': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await sendCalls({
+                    params: request.params || [],
+                    signer,
+                    account,
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                    policyId: this.#policyId,
+                });
+            }
+            case 'wallet_grantPermissions': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await registerSession({
+                    params: (request.params || []),
+                    signer,
+                    account,
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                    policyId: this.#policyId,
+                });
+            }
+            // EIP-7715: Wallet Session Key API
+            case 'wallet_revokePermissions': {
+                const account = Account.fromStorage(this.#storage);
+                const signer = SignerManager.fromStorage();
+                const authentication = Authentication.fromStorage(this.#storage);
+                if (!account || !signer || !authentication) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await revokeSession({
+                    params: (request.params || {}),
+                    signer,
+                    account,
+                    authentication,
+                    backendClient: this.#backendApiClients,
+                });
+            }
+            case 'wallet_getCapabilities': {
+                const { chainId } = await this.#rpcProvider.detectNetwork();
+                const capabilities = {
+                    [hexlify(chainId)]: {
+                        permissions: {
+                            supported: true,
+                            signerTypes: ['account', 'key'],
+                            keyTypes: ['secp256k1'],
+                            permissionTypes: ['contract-calls'],
+                        },
+                    },
+                };
+                return capabilities;
+            }
             // Pass through methods
             case 'eth_gasPrice':
             case 'eth_getBalance':
@@ -6141,7 +6594,7 @@ class EvmProvider {
                 return this.#rpcProvider.send(request.method, request.params || []);
             }
             default: {
-                throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
+                throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, `${request.method}: Method not supported`);
             }
         }
     }
@@ -6285,7 +6738,7 @@ class Openfort {
      * @returns A Provider instance.
      * @throws {OpenfortError} If the signer is not an EmbeddedSigner.
      */
-    getEthereumProvider(options = { announceProvider: true }) {
+    getEthereumProvider(options = {}) {
         const authentication = Authentication.fromStorage(this.storage);
         const signer = SignerManager.fromStorage();
         const account = Account.fromStorage(this.storage);
@@ -6298,12 +6751,10 @@ class Openfort {
             backendApiClients: this.backendApiClients,
             policyId: options.policy,
         });
-        if (options?.announceProvider) {
-            announceProvider({
-                info: openfortProviderInfo,
-                provider,
-            });
-        }
+        announceProvider({
+            info: { ...openfortProviderInfo, ...options.providerInfo },
+            provider,
+        });
         return provider;
     }
     /**
@@ -6383,7 +6834,9 @@ class Openfort {
         // eslint-disable-next-line no-param-reassign
         delete types.EIP712Domain;
         const account = Account.fromStorage(this.storage);
-        if (account && account.type === AccountType.UPGRADEABLE_V5) {
+        if (account && [AccountType.UPGRADEABLE_V5,
+            AccountType.UPGRADEABLE_V6,
+            AccountType.ZKSYNC_UPGRADEABLE_V1].includes(account.type)) {
             const updatedDomain = {
                 name: 'Openfort',
                 version: '0.5',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/openfort-js",
-  "version": "0.8.12",
+  "version": "0.8.13",
   "author": "Openfort (https://www.openfort.xyz)",
   "bugs": "https://github.com/openfort-xyz/openfort-js/issues",
   "repository": "openfort-xyz/openfort-js.git",