@openfort/openfort-js 0.7.2 → 0.7.3

package/dist/index.cjs

@@ -4,10 +4,13 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var hash = require('@ethersproject/hash');
 var globalAxios = require('axios');
+var providers = require('@ethersproject/providers');
+var bytes = require('@ethersproject/bytes');
+var events = require('events');
+var uuid = require('uuid');
 var jose = require('jose');
 var secp256k1 = require('@noble/curves/secp256k1');
 var signingKey = require('@ethersproject/signing-key');
-var bytes = require('@ethersproject/bytes');
 var transactions = require('@ethersproject/transactions');
 
 exports.EmbeddedState = void 0;
@@ -18,6 +21,10 @@ exports.EmbeddedState = void 0;
     EmbeddedState[EmbeddedState["CREATING_ACCOUNT"] = 3] = "CREATING_ACCOUNT";
     EmbeddedState[EmbeddedState["READY"] = 4] = "READY";
 })(exports.EmbeddedState || (exports.EmbeddedState = {}));
+var OpenfortEvents;
+(function (OpenfortEvents) {
+    OpenfortEvents["LOGGED_OUT"] = "loggedOut";
+})(OpenfortEvents || (OpenfortEvents = {}));
 var AccountType;
 (function (AccountType) {
     AccountType["UPGRADEABLE_V4"] = "Upgradeable_v04";
@@ -3049,6 +3056,1446 @@ class SDKConfiguration {
     }
 }
 
+const chain$m = {
+    chain: 'BSC',
+    chainId: 56,
+    explorers: [
+        {
+            name: 'bscscan',
+            url: 'https://bscscan.com',
+            standard: 'EIP3091',
+        },
+        {
+            name: 'dexguru',
+            url: 'https://bnb.dex.guru',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmRaASKRSjQ5btoUQ2rNTJNxKtx2a2RoewgA7DMQkLVEne',
+                width: 83,
+                height: 82,
+                format: 'svg',
+            },
+        },
+    ],
+    faucets: [],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/binance-coin/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://www.bnbchain.org/en',
+    name: 'BNB Smart Chain Mainnet',
+    nativeCurrency: {
+        name: 'BNB Chain Native Token',
+        symbol: 'BNB',
+        decimals: 18,
+    },
+    networkId: 56,
+    redFlags: [],
+    rpc: [
+        'https://bsc.publicnode.com',
+        'https://bsc-dataseed1.bnbchain.org',
+        'https://bsc-dataseed2.bnbchain.org',
+        'https://bsc-dataseed3.bnbchain.org',
+        'https://bsc-dataseed4.bnbchain.org',
+        'https://bsc-dataseed1.defibit.io',
+        'https://bsc-dataseed2.defibit.io',
+        'https://bsc-dataseed3.defibit.io',
+        'https://bsc-dataseed4.defibit.io',
+        'https://bsc-dataseed1.ninicoin.io',
+        'https://bsc-dataseed2.ninicoin.io',
+        'https://bsc-dataseed3.ninicoin.io',
+        'https://bsc-dataseed4.ninicoin.io',
+        'wss://bsc.publicnode.com',
+        'wss://bsc-ws-node.nariox.org',
+    ],
+    shortName: 'bnb',
+    slip44: 714,
+    slug: 'binance',
+    testnet: false,
+};
+
+const chain$l = {
+    chain: 'BSC',
+    chainId: 97,
+    explorers: [
+        {
+            name: 'bscscan-testnet',
+            url: 'https://testnet.bscscan.com',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: ['https://testnet.bnbchain.org/faucet-smart'],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/binance-coin/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://www.bnbchain.org/en',
+    name: 'BNB Smart Chain Testnet',
+    nativeCurrency: {
+        name: 'BNB Chain Native Token',
+        symbol: 'tBNB',
+        decimals: 18,
+    },
+    networkId: 97,
+    redFlags: [],
+    rpc: [
+        'https://bsc-testnet.publicnode.com',
+        'https://data-seed-prebsc-1-s1.bnbchain.org:8545',
+        'https://data-seed-prebsc-2-s1.bnbchain.org:8545',
+        'https://data-seed-prebsc-1-s2.bnbchain.org:8545',
+        'https://data-seed-prebsc-2-s2.bnbchain.org:8545',
+        'https://data-seed-prebsc-1-s3.bnbchain.org:8545',
+        'https://data-seed-prebsc-2-s3.bnbchain.org:8545',
+    ],
+    shortName: 'bnbt',
+    slug: 'binance-testnet',
+    testnet: true,
+};
+
+const chain$k = {
+    name: 'Base',
+    chain: 'ETH',
+    rpc: [
+        'https://mainnet.base.org',
+    ],
+    faucets: [],
+    nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    infoURL: 'https://base.org',
+    shortName: 'base',
+    chainId: 8453,
+    networkId: 8453,
+    icon: {
+        url: 'ipfs://QmW5Vn15HeRkScMfPcW12ZdZcC2yUASpu6eCsECRdEmjjj/base-512.png',
+        height: 512,
+        width: 512,
+        format: 'png',
+    },
+    explorers: [
+        {
+            name: 'basescout',
+            url: 'https://base.blockscout.com',
+            icon: {
+                url: 'ipfs://QmYtUimyqHkkFxYdbXXRbUqNg2VLPUg6Uu2C2nmFWowiZM',
+                width: 551,
+                height: 540,
+                format: 'png',
+            },
+            standard: 'EIP3091',
+        },
+        {
+            name: 'basescan',
+            url: 'https://basescan.org',
+            standard: 'none',
+        },
+    ],
+    status: 'active',
+    testnet: false,
+    slug: 'base',
+};
+
+const chain$j = {
+    chain: 'ETH',
+    chainId: 84532,
+    explorers: [
+        {
+            name: 'basescout',
+            url: 'https://base-sepolia.blockscout.com',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmYtUimyqHkkFxYdbXXRbUqNg2VLPUg6Uu2C2nmFWowiZM',
+                width: 551,
+                height: 540,
+                format: 'png',
+            },
+        },
+    ],
+    faucets: [],
+    icon: {
+        url: 'ipfs://QmaxRoHpxZd8PqccAynherrMznMufG6sdmHZLihkECXmZv',
+        width: 1200,
+        height: 1200,
+        format: 'png',
+    },
+    infoURL: 'https://base.org',
+    name: 'Base Sepolia Testnet',
+    nativeCurrency: {
+        name: 'Sepolia Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 84532,
+    rpc: [
+        'https://sepolia.base.org',
+    ],
+    shortName: 'basesep',
+    slug: 'base-sepolia-testnet',
+    testnet: true,
+};
+
+const chain$i = {
+    name: 'Beam',
+    chainId: 4337,
+    chain: 'BEAM',
+    shortName: 'Beam',
+    slug: 'beam',
+    icon: {
+        url: 'ipfs://QmQJ21NWyGGDraicVEzS1Uqq1yXahM9NCuNZgnfYvtspdt',
+        height: 512,
+        width: 512,
+        format: 'png',
+    },
+    features: [
+        {
+            name: 'EIP1559',
+        },
+    ],
+    nativeCurrency: {
+        name: 'Beam',
+        symbol: 'BEAM',
+        decimals: 18,
+    },
+    rpc: [
+        'https://eu.build.onbeam.com/rpc/14bfbcc5-49c1-40e8-82c2-025c9a1834e1',
+    ],
+    faucets: ['https://faucet.onbeam.com'],
+    explorers: [
+        {
+            name: 'Beam Explorer',
+            url: 'https://subnets.avax.network/beam/',
+            standard: 'EIP3091',
+        },
+    ],
+    infoURL: 'https://gaming.meritcircle.io/',
+    testnet: false,
+};
+
+const chain$h = {
+    name: 'Beam Testnet',
+    chainId: 13337,
+    chain: 'BEAM',
+    shortName: 'Beam Testnet',
+    slug: 'beam-testnet',
+    features: [
+        {
+            name: 'EIP1559',
+        },
+    ],
+    icon: {
+        url: 'ipfs://QmQJ21NWyGGDraicVEzS1Uqq1yXahM9NCuNZgnfYvtspdt',
+        height: 512,
+        width: 512,
+        format: 'png',
+    },
+    nativeCurrency: {
+        name: 'Beam',
+        symbol: 'BEAM',
+        decimals: 18,
+    },
+    rpc: [
+        'https://eu.build.onbeam.com/rpc/testnet/14bfbcc5-49c1-40e8-82c2-025c9a1834e1',
+    ],
+    faucets: ['https://faucet.avax.network/?subnet=beam', 'https://faucet.onbeam.com'],
+    explorers: [
+        {
+            name: 'Beam Explorer',
+            url: 'https://subnets-test.avax.network/beam',
+            standard: 'EIP3091',
+        },
+    ],
+    infoURL: 'https://www.onbeam.com',
+    testnet: true,
+};
+
+const chain$g = {
+    chain: 'AVAX',
+    chainId: 43113,
+    explorers: [
+        {
+            name: 'snowtrace',
+            url: 'https://testnet.snowtrace.io',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: ['https://faucet.avax-test.network/'],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/avalanche/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://cchain.explorer.avax-test.network',
+    name: 'Avalanche Fuji Testnet',
+    nativeCurrency: {
+        name: 'Avalanche',
+        symbol: 'AVAX',
+        decimals: 18,
+    },
+    networkId: 43113,
+    redFlags: [],
+    rpc: [
+        'https://api.avax-test.network/ext/bc/C/rpc',
+        'https://avalanche-fuji-c-chain.publicnode.com',
+    ],
+    shortName: 'Fuji',
+    slug: 'avalanche-fuji',
+    testnet: true,
+};
+
+const chain$f = {
+    chain: 'AVAX',
+    chainId: 43114,
+    explorers: [
+        {
+            name: 'snowtrace',
+            url: 'https://snowtrace.io',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: [],
+    features: [
+        {
+            name: 'EIP1559',
+        },
+    ],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/avalanche/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://www.avax.network/',
+    name: 'Avalanche C-Chain',
+    nativeCurrency: {
+        name: 'Avalanche',
+        symbol: 'AVAX',
+        decimals: 18,
+    },
+    networkId: 43114,
+    redFlags: [],
+    rpc: [
+        'https://api.avax.network/ext/bc/C/rpc',
+        'https://avalanche-c-chain.publicnode.com',
+    ],
+    shortName: 'avax',
+    slip44: 9005,
+    slug: 'avalanche',
+    testnet: false,
+};
+
+const chain$e = {
+    chain: 'ETH',
+    chainId: 11155111,
+    explorers: [
+        {
+            name: 'etherscan-sepolia',
+            url: 'https://sepolia.etherscan.io',
+            standard: 'EIP3091',
+        },
+        {
+            name: 'otterscan-sepolia',
+            url: 'https://sepolia.otterscan.io',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: ['http://fauceth.komputing.org?chain=11155111'],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/ethereum/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://sepolia.otterscan.io',
+    name: 'Sepolia',
+    nativeCurrency: {
+        name: 'Sepolia Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 11155111,
+    redFlags: [],
+    rpc: [
+        'https://rpc.sepolia.org',
+        'https://rpc2.sepolia.org',
+        'https://rpc-sepolia.rockx.com',
+        'https://rpc.sepolia.ethpandaops.io',
+        'https://sepolia.gateway.tenderly.co',
+        'https://ethereum-sepolia.publicnode.com',
+    ],
+    shortName: 'sep',
+    slug: 'sepolia',
+    testnet: true,
+    title: 'Ethereum Testnet Sepolia',
+};
+
+const chain$d = {
+    chain: 'ETH',
+    chainId: 59140,
+    explorers: [
+        {
+            name: 'Etherscan',
+            url: 'https://goerli.lineascan.build',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmURjritnHL7a8TwZgsFwp3f272DJmG5paaPtWDZ98QZwH',
+                width: 97,
+                height: 102,
+                format: 'svg',
+            },
+        },
+        {
+            name: 'Blockscout',
+            url: 'https://explorer.goerli.linea.build',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmURjritnHL7a8TwZgsFwp3f272DJmG5paaPtWDZ98QZwH',
+                width: 97,
+                height: 102,
+                format: 'svg',
+            },
+        },
+    ],
+    faucets: ['https://faucetlink.to/goerli'],
+    icon: {
+        url: 'ipfs://QmURjritnHL7a8TwZgsFwp3f272DJmG5paaPtWDZ98QZwH',
+        width: 97,
+        height: 102,
+        format: 'svg',
+    },
+    infoURL: 'https://linea.build',
+    name: 'Linea Testnet',
+    nativeCurrency: {
+        name: 'Linea Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 59140,
+    parent: {
+        type: 'L2',
+        chain: 'eip155-5',
+        bridges: [
+            {
+                url: 'https://goerli.hop.exchange/#/send?token=ETH&sourceNetwork=ethereum&destNetwork=linea',
+            },
+        ],
+    },
+    rpc: [
+        'https://rpc.goerli.linea.build',
+        'wss://rpc.goerli.linea.build',
+    ],
+    shortName: 'linea-testnet',
+    slug: 'linea-testnet',
+    status: 'active',
+    testnet: true,
+    title: 'Linea Goerli Testnet',
+};
+
+const chain$c = {
+    chain: 'GNO',
+    chainId: 10200,
+    explorers: [
+        {
+            name: 'blockscout',
+            url: 'https://gnosis-chiado.blockscout.com',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmYtUimyqHkkFxYdbXXRbUqNg2VLPUg6Uu2C2nmFWowiZM',
+                width: 551,
+                height: 540,
+                format: 'png',
+            },
+        },
+    ],
+    faucets: ['https://gnosisfaucet.com'],
+    icon: {
+        url: 'ipfs://bafybeidk4swpgdyqmpz6shd5onvpaujvwiwthrhypufnwr6xh3dausz2dm',
+        width: 1800,
+        height: 1800,
+        format: 'png',
+    },
+    infoURL: 'https://docs.gnosischain.com',
+    name: 'Gnosis Chiado Testnet',
+    nativeCurrency: {
+        name: 'Chiado xDAI',
+        symbol: 'XDAI',
+        decimals: 18,
+    },
+    networkId: 10200,
+    rpc: [
+        'https://rpc.chiadochain.net',
+        'https://rpc.chiado.gnosis.gateway.fm',
+        'wss://rpc.chiadochain.net/wss',
+        'https://gnosis-chiado-rpc.publicnode.com',
+        'wss://gnosis-chiado-rpc.publicnode.com',
+        'https://gnosis-chiado.drpc.org',
+        'wss://gnosis-chiado.drpc.org',
+    ],
+    shortName: 'chi',
+    slip44: 1,
+    slug: 'gnosis-chiado-testnet',
+    testnet: true,
+};
+
+const chain$b = {
+    chain: 'Immutable zkEVM',
+    chainId: 13371,
+    explorers: [
+        {
+            name: 'Immutable explorer',
+            url: 'https://explorer.immutable.com',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmXFUYFW4e6wifbU9LKVq7owM14bnE6ZbbYq3bn1jBP3Mw',
+                width: 1168,
+                height: 1168,
+                format: 'png',
+            },
+        },
+    ],
+    faucets: ['https://docs.immutable.com/docs/zkEVM/guides/faucet'],
+    icon: {
+        url: 'ipfs://QmXFUYFW4e6wifbU9LKVq7owM14bnE6ZbbYq3bn1jBP3Mw',
+        width: 1168,
+        height: 1168,
+        format: 'png',
+    },
+    infoURL: 'https://www.immutable.com',
+    name: 'Immutable zkEVM',
+    nativeCurrency: {
+        name: 'IMX',
+        symbol: 'IMX',
+        decimals: 18,
+    },
+    networkId: 13371,
+    rpc: [
+        'https://rpc.immutable.com',
+        'https://immutable-zkevm.drpc.org',
+        'wss://immutable-zkevm.drpc.org',
+    ],
+    shortName: 'imx',
+    slug: 'immutable-zkevm',
+    testnet: false,
+};
+
+const chain$a = {
+    chain: 'ETH',
+    chainId: 421614,
+    explorers: [
+        {
+            name: 'Arbitrum Sepolia Rollup Testnet Explorer',
+            url: 'https://sepolia-explorer.arbitrum.io',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: [],
+    infoURL: 'https://arbitrum.io',
+    name: 'Arbitrum Sepolia',
+    nativeCurrency: {
+        name: 'Sepolia Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 421614,
+    parent: {
+        type: 'L2',
+        chain: 'eip155-11155111',
+        bridges: [
+            {
+                url: 'https://bridge.arbitrum.io',
+            },
+        ],
+    },
+    rpc: [
+        'https://sepolia-rollup.arbitrum.io/rpc',
+    ],
+    shortName: 'arb-sep',
+    slug: 'arbitrum-sepolia',
+    testnet: true,
+    title: 'Arbitrum Sepolia Rollup Testnet',
+};
+
+const chain$9 = {
+    chain: 'ETH',
+    chainId: 42161,
+    explorers: [
+        {
+            name: 'Arbiscan',
+            url: 'https://arbiscan.io',
+            standard: 'EIP3091',
+        },
+        {
+            name: 'Arbitrum Explorer',
+            url: 'https://explorer.arbitrum.io',
+            standard: 'EIP3091',
+        },
+        {
+            name: 'dexguru',
+            url: 'https://arbitrum.dex.guru',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmRaASKRSjQ5btoUQ2rNTJNxKtx2a2RoewgA7DMQkLVEne',
+                width: 83,
+                height: 82,
+                format: 'svg',
+            },
+        },
+    ],
+    faucets: [],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/arbitrum/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://arbitrum.io',
+    name: 'Arbitrum One',
+    nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 42161,
+    parent: {
+        type: 'L2',
+        chain: 'eip155-1',
+        bridges: [
+            {
+                url: 'https://bridge.arbitrum.io',
+            },
+        ],
+    },
+    redFlags: [],
+    rpc: [
+        'https://arb1.arbitrum.io/rpc',
+        'https://arbitrum-one.publicnode.com',
+        'wss://arbitrum-one.publicnode.com',
+    ],
+    shortName: 'arb1',
+    slug: 'arbitrum',
+    testnet: false,
+};
+
+const chain$8 = {
+    chain: 'ETH',
+    chainId: 42170,
+    explorers: [
+        {
+            name: 'Arbitrum Nova Chain Explorer',
+            url: 'https://nova-explorer.arbitrum.io',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmYtUimyqHkkFxYdbXXRbUqNg2VLPUg6Uu2C2nmFWowiZM',
+                width: 551,
+                height: 540,
+                format: 'png',
+            },
+        },
+        {
+            name: 'dexguru',
+            url: 'https://nova.dex.guru',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmRaASKRSjQ5btoUQ2rNTJNxKtx2a2RoewgA7DMQkLVEne',
+                width: 83,
+                height: 82,
+                format: 'svg',
+            },
+        },
+    ],
+    faucets: [],
+    infoURL: 'https://arbitrum.io',
+    name: 'Arbitrum Nova',
+    nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 42170,
+    parent: {
+        type: 'L2',
+        chain: 'eip155-1',
+        bridges: [
+            {
+                url: 'https://bridge.arbitrum.io',
+            },
+        ],
+    },
+    rpc: [
+        'https://nova.arbitrum.io/rpc',
+        'https://arbitrum-nova.publicnode.com',
+        'wss://arbitrum-nova.publicnode.com',
+    ],
+    shortName: 'arb-nova',
+    slug: 'arbitrum-nova',
+    testnet: false,
+};
+
+const chain$7 = {
+    chain: 'Polygon',
+    chainId: 137,
+    explorers: [
+        {
+            name: 'polygonscan',
+            url: 'https://polygonscan.com',
+            standard: 'EIP3091',
+        },
+        {
+            name: 'dexguru',
+            url: 'https://polygon.dex.guru',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmRaASKRSjQ5btoUQ2rNTJNxKtx2a2RoewgA7DMQkLVEne',
+                width: 83,
+                height: 82,
+                format: 'svg',
+            },
+        },
+    ],
+    faucets: [],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/polygon/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://polygon.technology/',
+    name: 'Polygon Mainnet',
+    nativeCurrency: {
+        name: 'MATIC',
+        symbol: 'MATIC',
+        decimals: 18,
+    },
+    networkId: 137,
+    redFlags: [],
+    rpc: [
+        'https://polygon-rpc.com',
+        'https://rpc-mainnet.matic.network',
+        'https://matic-mainnet.chainstacklabs.com',
+        'https://rpc-mainnet.maticvigil.com',
+        'https://rpc-mainnet.matic.quiknode.pro',
+        'https://matic-mainnet-full-rpc.bwarelabs.com',
+        'https://polygon-bor.publicnode.com',
+        'wss://polygon-bor.publicnode.com',
+        'https://polygon.gateway.tenderly.co',
+        'wss://polygon.gateway.tenderly.co',
+    ],
+    shortName: 'matic',
+    slip44: 966,
+    slug: 'polygon',
+    testnet: false,
+};
+
+const chain$6 = {
+    chain: 'Polygon',
+    chainId: 80002,
+    explorers: [
+        {
+            name: 'polygonamoy',
+            url: 'https://www.oklink.com/amoy',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: ['https://faucet.polygon.technology/'],
+    features: [],
+    icon: {
+        url: 'ipfs://QmcxZHpyJa8T4i63xqjPYrZ6tKrt55tZJpbXcjSDKuKaf9/polygon/512.png',
+        width: 512,
+        height: 512,
+        format: 'png',
+    },
+    infoURL: 'https://polygon.technology/',
+    name: 'Polygon Amoy Testnet',
+    nativeCurrency: {
+        name: 'MATIC',
+        symbol: 'MATIC',
+        decimals: 18,
+    },
+    networkId: 80002,
+    redFlags: [],
+    rpc: [
+        'https://rpc-amoy.polygon.technology',
+    ],
+    shortName: 'polygonamoy',
+    slip44: 1,
+    slug: 'polygon-amoy-testnet',
+    testnet: true,
+    title: 'Polygon Amoy Testnet',
+};
+
+const chain$5 = {
+    chain: 'Ancient8',
+    chainId: 28122024,
+    explorers: [
+        {
+            name: 'scan-testnet',
+            url: 'https://scanv2-testnet.ancient8.gg',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: [],
+    icon: {
+        url: 'ipfs://bafkreievnqg3xjokaty4kfbxxbrzm5v5y7exbaaia2txrh4sfgrqsalfym',
+        width: 128,
+        height: 128,
+        format: 'png',
+    },
+    infoURL: 'https://ancient8.gg/',
+    name: 'Ancient8 Testnet',
+    nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 28122024,
+    rpc: ['https://rpcv2-testnet.ancient8.gg'],
+    shortName: 'a8',
+    slip44: 1,
+    slug: 'ancient8-testnet',
+    testnet: true,
+};
+
+const chain$4 = {
+    chain: 'Ancient8',
+    chainId: 888888888,
+    explorers: [
+        {
+            name: 'Ancient8 Explorer',
+            url: 'https://scan.ancient8.gg',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: [],
+    icon: {
+        url: 'ipfs://bafkreievnqg3xjokaty4kfbxxbrzm5v5y7exbaaia2txrh4sfgrqsalfym',
+        width: 128,
+        height: 128,
+        format: 'png',
+    },
+    infoURL: 'https://ancient8.gg/',
+    name: 'Ancient8',
+    nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 888888888,
+    rpc: ['https://rpc.ancient8.gg'],
+    shortName: 'ancient8',
+    slug: 'ancient8',
+    testnet: false,
+};
+
+const chain$3 = {
+    chain: 'ETH',
+    chainId: 999999999,
+    explorers: [
+        {
+            name: 'Zora Sepolia Testnet Network Explorer',
+            url: 'https://sepolia.explorer.zora.energy',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: [],
+    icon: {
+        url: 'ipfs://bafkreifvrly5tgd34xqeo67s4etmiu52bkroml7uy7eosizf57htf5nrzq',
+        width: 250,
+        height: 250,
+        format: 'png',
+    },
+    infoURL: 'https://zora.energy',
+    name: 'Zora Sepolia Testnet',
+    nativeCurrency: {
+        name: 'Sepolia Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 999999999,
+    rpc: ['https://sepolia.rpc.zora.energy'],
+    shortName: 'zsep',
+    slip44: 1,
+    slug: 'zora-sepolia-testnet',
+    testnet: true,
+};
+
+const chain$2 = {
+    chain: 'ETH',
+    chainId: 7777777,
+    explorers: [
+        {
+            name: 'Zora Network Explorer',
+            url: 'https://explorer.zora.energy',
+            standard: 'EIP3091',
+        },
+    ],
+    faucets: [],
+    features: [],
+    icon: {
+        url: 'ipfs://QmZ6qaRwTPFEZUspwMUjaxC6KhmzcELdRQcQzS3P72Dzts/Vector.svg',
+        width: 512,
+        height: 512,
+        format: 'svg',
+    },
+    infoURL: 'https://zora.energy',
+    name: 'Zora',
+    nativeCurrency: {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+    },
+    networkId: 7777777,
+    redFlags: [],
+    rpc: ['https://rpc.zora.energy/'],
+    shortName: 'zora',
+    slug: 'zora',
+    testnet: false,
+};
+
+const chain$1 = {
+    chain: 'Degen',
+    chainId: 666666666,
+    explorers: [],
+    faucets: [],
+    icon: {
+        url: 'ipfs://Qmb6yAe4wXeBkxjfhxzoUT9TzETcmE7Vne59etm9GJaQf7',
+        width: 789,
+        height: 668,
+        format: 'svg',
+    },
+    infoURL: 'https://degen.tips',
+    name: 'Degen Chain',
+    nativeCurrency: {
+        name: 'DEGEN',
+        symbol: 'DEGEN',
+        decimals: 18,
+    },
+    networkId: 666666666,
+    rpc: ['https://rpc.degen.tips'],
+    shortName: 'degen-chain',
+    slug: 'degen-chain',
+    status: 'incubating',
+    testnet: false,
+    title: 'Degen Chain',
+};
+
+const chain = {
+    chain: 'Immutable zkEVM',
+    chainId: 13473,
+    explorers: [
+        {
+            name: 'Immutable Testnet explorer',
+            url: 'https://explorer.testnet.immutable.com',
+            standard: 'EIP3091',
+            icon: {
+                url: 'ipfs://QmXFUYFW4e6wifbU9LKVq7owM14bnE6ZbbYq3bn1jBP3Mw',
+                width: 1168,
+                height: 1168,
+                format: 'png',
+            },
+        },
+    ],
+    faucets: ['https://docs.immutable.com/docs/zkEVM/guides/faucet'],
+    icon: {
+        url: 'ipfs://QmXFUYFW4e6wifbU9LKVq7owM14bnE6ZbbYq3bn1jBP3Mw',
+        width: 1168,
+        height: 1168,
+        format: 'png',
+    },
+    infoURL: 'https://www.immutable.com',
+    name: 'Immutable zkEVM Testnet',
+    nativeCurrency: {
+        name: 'Test IMX',
+        symbol: 'tIMX',
+        decimals: 18,
+    },
+    networkId: 13473,
+    rpc: [
+        'https://rpc.testnet.immutable.com',
+        'https://immutable-zkevm-testnet.drpc.org',
+        'wss://immutable-zkevm-testnet.drpc.org',
+    ],
+    shortName: 'imx-testnet',
+    slip44: 1,
+    slug: 'immutable-zkevm-testnet',
+    testnet: true,
+};
+
+const chainMap = {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    56: chain$m,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    97: chain$l,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    8453: chain$k,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    84532: chain$j,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    4337: chain$i,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    13337: chain$h,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    43113: chain$g,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    43114: chain$f,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    11155111: chain$e,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    59140: chain$d,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    10200: chain$c,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    421614: chain$a,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    42161: chain$9,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    42170: chain$8,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    137: chain$7,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    80002: chain$6,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    28122024: chain$5,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    888888888: chain$4,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    999999999: chain$3,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    7777777: chain$2,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    666666666: chain$1,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    13473: chain,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    13371: chain$b,
+};
+
+var BackendTransactionStatus;
+(function (BackendTransactionStatus) {
+    BackendTransactionStatus["PENDING"] = "PENDING";
+    BackendTransactionStatus["SUBMITTED"] = "SUBMITTED";
+    BackendTransactionStatus["SUCCESSFUL"] = "SUCCESSFUL";
+    BackendTransactionStatus["REVERTED"] = "REVERTED";
+    BackendTransactionStatus["FAILED"] = "FAILED";
+    BackendTransactionStatus["CANCELLED"] = "CANCELLED";
+})(BackendTransactionStatus || (BackendTransactionStatus = {}));
+var ProviderEvent;
+(function (ProviderEvent) {
+    ProviderEvent["ACCOUNTS_CHANGED"] = "accountsChanged";
+})(ProviderEvent || (ProviderEvent = {}));
+
+class TypedEventEmitter {
+    emitter = new events.EventEmitter();
+    emit(eventName, ...eventArg) {
+        this.emitter.emit(eventName, ...eventArg);
+    }
+    on(eventName, handler) {
+        this.emitter.on(eventName, handler);
+    }
+    removeListener(eventName, handler) {
+        this.emitter.removeListener(eventName, handler);
+    }
+}
+
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+var ProviderErrorCode;
+(function (ProviderErrorCode) {
+    ProviderErrorCode[ProviderErrorCode["USER_REJECTED_REQUEST"] = 4001] = "USER_REJECTED_REQUEST";
+    ProviderErrorCode[ProviderErrorCode["UNAUTHORIZED"] = 4100] = "UNAUTHORIZED";
+    ProviderErrorCode[ProviderErrorCode["UNSUPPORTED_METHOD"] = 4200] = "UNSUPPORTED_METHOD";
+    ProviderErrorCode[ProviderErrorCode["DISCONNECTED"] = 4900] = "DISCONNECTED";
+})(ProviderErrorCode || (ProviderErrorCode = {}));
+var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode[RpcErrorCode["RPC_SERVER_ERROR"] = -32000] = "RPC_SERVER_ERROR";
+    RpcErrorCode[RpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    RpcErrorCode[RpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    RpcErrorCode[RpcErrorCode["TRANSACTION_REJECTED"] = -32003] = "TRANSACTION_REJECTED";
+})(RpcErrorCode || (RpcErrorCode = {}));
+class JsonRpcError extends Error {
+    message;
+    code;
+    constructor(code, message) {
+        super(message);
+        this.message = message;
+        this.code = code;
+    }
+}
+
+const buildOpenfortTransactions = async (transactionRequest, backendApiClients, instanceManager, policyId) => {
+    const interactions = transactionRequest.map((tx) => {
+        if (!tx.to) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
+        }
+        return {
+            to: String(tx.to),
+            data: tx.data ? String(tx.data) : undefined,
+            value: tx.value ? String(tx.value) : undefined,
+        };
+    });
+    const accessToken = instanceManager.getAccessToken();
+    const chainId = instanceManager.getChainID();
+    if (!accessToken || !chainId) {
+        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'No access token found');
+    }
+    const transactionResponse = await backendApiClients.transactionIntentsApi.createTransactionIntent({
+        createTransactionIntentRequest: {
+            policy: policyId,
+            chainId: Number(chainId),
+            interactions,
+        },
+    }, {
+        headers: {
+            authorization: `Bearer ${backendApiClients.config.backend.accessToken}`,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-player-token': accessToken.token,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-auth-provider': accessToken.thirdPartyProvider,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'x-token-type': accessToken.thirdPartyTokenType,
+        },
+    });
+    return transactionResponse.data;
+};
+const sendTransaction = async ({ params, signer, backendClient, instanceManager, policyId, }) => {
+    const openfortTransaction = await buildOpenfortTransactions(params, backendClient, instanceManager, policyId);
+    let response;
+    if (openfortTransaction?.nextAction?.payload?.userOperationHash) {
+        const signature = await signer.sign(openfortTransaction.nextAction.payload.userOperationHash);
+        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 getSignedTypedData = async (typedData, accountType, chainId, signer, evmAddress) => {
+    // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
+    const types = { ...typedData.types };
+    // @ts-ignore
+    delete types.EIP712Domain;
+    // Hash the EIP712 payload and generate the complete payload
+    let typedDataHash = hash._TypedDataEncoder.hash(typedData.domain, types, typedData.message);
+    if (accountType === AccountType.UPGRADEABLE_V5) {
+        const updatedDomain = {
+            name: 'Openfort',
+            version: '0.5',
+            chainId: Number(chainId),
+            verifyingContract: evmAddress,
+        };
+        const updatedTypes = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            OpenfortMessage: [{ name: 'hashedMessage', type: 'bytes32' }],
+        };
+        const updatedMessage = {
+            hashedMessage: typedDataHash,
+        };
+        typedDataHash = hash._TypedDataEncoder.hash(updatedDomain, updatedTypes, updatedMessage);
+        // primaryType: "OpenfortMessage"
+    }
+    const ethsigNoType = await signer.sign(typedDataHash, false, false);
+    return ethsigNoType;
+};
+
+const REQUIRED_TYPED_DATA_PROPERTIES = ['types', 'domain', 'primaryType', 'message'];
+const isValidTypedDataPayload = (typedData) => (REQUIRED_TYPED_DATA_PROPERTIES.every((key) => key in typedData));
+const transformTypedData = (typedData, chainId) => {
+    let transformedTypedData;
+    if (typeof typedData === 'string') {
+        try {
+            transformedTypedData = JSON.parse(typedData);
+        }
+        catch (err) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Failed to parse typed data JSON: ${err}`);
+        }
+    }
+    else if (typeof typedData === 'object') {
+        transformedTypedData = typedData;
+    }
+    else {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid typed data argument: ${typedData}`);
+    }
+    if (!isValidTypedDataPayload(transformedTypedData)) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid typed data argument. The following properties are required: 
+      ${REQUIRED_TYPED_DATA_PROPERTIES.join(', ')}`);
+    }
+    const providedChainId = transformedTypedData.domain?.chainId;
+    if (providedChainId) {
+        // domain.chainId (if defined) can be a number, string, or hex value, but the backend & guardian only accept a number.
+        if (typeof providedChainId === 'string') {
+            if (providedChainId.startsWith('0x')) {
+                transformedTypedData.domain.chainId = parseInt(providedChainId, 16);
+            }
+            else {
+                transformedTypedData.domain.chainId = parseInt(providedChainId, 10);
+            }
+        }
+        if (transformedTypedData.domain.chainId !== chainId) {
+            throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Invalid chainId, expected ${chainId}`);
+        }
+    }
+    return transformedTypedData;
+};
+const signTypedDataV4 = async ({ params, method, signer, accountType, rpcProvider, }) => {
+    const fromAddress = params[0];
+    const typedDataParam = params[1];
+    if (!fromAddress || !typedDataParam) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `${method} requires an address and a typed data JSON`);
+    }
+    const { chainId } = await rpcProvider.detectNetwork();
+    const typedData = transformTypedData(typedDataParam, chainId);
+    const signature = await getSignedTypedData(typedData, accountType, chainId, signer, fromAddress);
+    return signature;
+};
+
+class EvmProvider {
+    #signer;
+    #policyId;
+    #eventEmitter;
+    #rpcProvider; // Used for read
+    #instanceManager;
+    #backendApiClients;
+    #address;
+    isOpenfort = true;
+    constructor({ signer, address, backendApiClients, instanceManager, openfortEventEmitter, policyId, }) {
+        this.#signer = signer;
+        this.#policyId = policyId;
+        this.#address = address;
+        this.#instanceManager = instanceManager;
+        this.#backendApiClients = backendApiClients;
+        const chainId = Number(this.#instanceManager.getChainID());
+        this.#rpcProvider = new providers.StaticJsonRpcProvider(chainMap[chainId].rpc[0]);
+        this.#backendApiClients = backendApiClients;
+        this.#eventEmitter = new TypedEventEmitter();
+        openfortEventEmitter.on(OpenfortEvents.LOGGED_OUT, this.#handleLogout);
+    }
+    #handleLogout = () => {
+        const shouldEmitAccountsChanged = !!this.#address;
+        this.#address = undefined;
+        this.#signer.logout();
+        if (shouldEmitAccountsChanged) {
+            this.#eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
+        }
+    };
+    async #performRequest(request) {
+        switch (request.method) {
+            case 'eth_requestAccounts': {
+                if (this.#address) {
+                    return [this.#address];
+                }
+                const user = await this.#signer.ensureEmbeddedAccount();
+                this.#address = user.address;
+                this.#eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.#address]);
+                return [this.#address];
+            }
+            case 'eth_sendTransaction': {
+                if (!this.#address) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await sendTransaction({
+                    params: request.params || [],
+                    signer: this.#signer,
+                    backendClient: this.#backendApiClients,
+                    instanceManager: this.#instanceManager,
+                    policyId: this.#policyId,
+                });
+            }
+            case 'eth_accounts': {
+                return this.#address ? [this.#address] : [];
+            }
+            case 'eth_signTypedData':
+            case 'eth_signTypedData_v4': {
+                if (!this.#address) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                const accountType = this.#instanceManager.getAccountType();
+                if (!accountType) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorized - call eth_requestAccounts first');
+                }
+                return await signTypedDataV4({
+                    method: request.method,
+                    params: request.params || [],
+                    signer: this.#signer,
+                    accountType,
+                    rpcProvider: this.#rpcProvider,
+                });
+            }
+            case 'eth_chainId': {
+                // Call detect network to fetch the chainId so to take advantage of
+                // the caching layer provided by StaticJsonRpcProvider.
+                // In case Openfort is changed from StaticJsonRpcProvider to a
+                // JsonRpcProvider, this function will still work as expected given
+                // that detectNetwork call _uncachedDetectNetwork which will force
+                // the provider to re-fetch the chainId from remote.
+                const { chainId } = await this.#rpcProvider.detectNetwork();
+                return bytes.hexlify(chainId);
+            }
+            // Pass through methods
+            case 'eth_gasPrice':
+            case 'eth_getBalance':
+            case 'eth_getCode':
+            case 'eth_getStorageAt':
+            case 'eth_estimateGas':
+            case 'eth_call':
+            case 'eth_blockNumber':
+            case 'eth_getBlockByHash':
+            case 'eth_getBlockByNumber':
+            case 'eth_getTransactionByHash':
+            case 'eth_getTransactionReceipt':
+            case 'eth_getTransactionCount': {
+                return this.#rpcProvider.send(request.method, request.params || []);
+            }
+            default: {
+                throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
+            }
+        }
+    }
+    async #performJsonRpcRequest(request) {
+        const { id, jsonrpc } = request;
+        try {
+            const result = await this.#performRequest(request);
+            return {
+                id,
+                jsonrpc,
+                result,
+            };
+        }
+        catch (error) {
+            let jsonRpcError;
+            if (error instanceof JsonRpcError) {
+                jsonRpcError = error;
+            }
+            else if (error instanceof Error) {
+                jsonRpcError = new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+            }
+            else {
+                jsonRpcError = new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+            }
+            return {
+                id,
+                jsonrpc,
+                error: jsonRpcError,
+            };
+        }
+    }
+    async request(request) {
+        try {
+            return this.#performRequest(request);
+        }
+        catch (error) {
+            if (error instanceof JsonRpcError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+            }
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+        }
+    }
+    sendAsync(request, callback) {
+        if (!callback) {
+            throw new Error('No callback provided');
+        }
+        if (Array.isArray(request)) {
+            Promise.all(request.map(this.#performJsonRpcRequest)).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, []);
+            });
+        }
+        else {
+            this.#performJsonRpcRequest(request).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, null);
+            });
+        }
+    }
+    async send(request, callbackOrParams, callback) {
+        // Web3 >= 1.0.0-beta.38 calls `send` with method and parameters.
+        if (typeof request === 'string') {
+            if (typeof callbackOrParams === 'function') {
+                return this.sendAsync({
+                    method: request,
+                    params: [],
+                }, callbackOrParams);
+            }
+            if (callback) {
+                return this.sendAsync({
+                    method: request,
+                    params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+                }, callback);
+            }
+            return this.request({
+                method: request,
+                params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+            });
+        }
+        // Web3 <= 1.0.0-beta.37 uses `send` with a callback for async queries.
+        if (typeof callbackOrParams === 'function') {
+            return this.sendAsync(request, callbackOrParams);
+        }
+        if (!Array.isArray(request) && typeof request === 'object') {
+            return this.#performJsonRpcRequest(request);
+        }
+        throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
+    }
+    on(event, listener) {
+        this.#eventEmitter.on(event, listener);
+    }
+    removeListener(event, listener) {
+        this.#eventEmitter.removeListener(event, listener);
+    }
+}
+
+const openfortProviderInfo = {
+    // eslint-disable-next-line max-len
+    icon: 'data:image/svg+xml,<svg aria-hidden="true" viewBox="597.32 331.34 171.36 105.32" ><g><rect x="673.9" y="404.26" width="18.2" height="32.4" /><polygon points="768.68,331.36 768.68,331.36 768.68,331.34 610.78,331.34 610.78,331.36 597.32,331.36 597.32,436.64    615.52,436.64 615.52,349.54 750.48,349.54 750.48,436.64 768.68,436.64  " /><polygon points="732.16,367.79 633.83,367.79 633.83,370.19 633.79,370.19 633.79,436.64 651.99,436.64 651.99,385.99    713.9,385.99 713.9,436.64 732.09,436.64 732.09,385.99 732.16,385.99  " /></g></svg>',
+    name: 'Ecosystem ID',
+    rdns: 'com.ecosystem.id',
+    uuid: uuid.v4(),
+};
+function announceProvider(detail) {
+    if (typeof window === 'undefined')
+        return;
+    const event = new CustomEvent('eip6963:announceProvider', { detail: Object.freeze(detail) });
+    window.dispatchEvent(event);
+    const handler = () => window.dispatchEvent(event);
+    window.addEventListener('eip6963:requestProvider', handler);
+}
+
 var SignerType;
 (function (SignerType) {
     SignerType["EMBEDDED"] = "embedded";
@@ -3254,7 +4701,7 @@ class AuthManager {
             headers: {
                 authorization: `Bearer ${this.config.baseConfiguration.publishableKey}`,
                 // eslint-disable-next-line @typescript-eslint/naming-convention
-                'player-token': accessToken,
+                'x-player-token': accessToken,
             },
         });
     }
@@ -4073,6 +5520,13 @@ class NotLoggedIn extends Error {
         Object.setPrototypeOf(this, NotLoggedIn.prototype);
     }
 }
+class EmbeddedNotConfigured extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EmbeddedNotConfigured';
+        Object.setPrototypeOf(this, EmbeddedNotConfigured.prototype);
+    }
+}
 class NoSignerConfigured extends Error {
     constructor(message) {
         super(message);
@@ -4094,11 +5548,13 @@ class Openfort {
     instanceManager;
     backendApiClients;
     iframeManager;
+    openfortEventEmitter;
     constructor(sdkConfiguration) {
         this.config = new SDKConfiguration(sdkConfiguration);
         this.backendApiClients = new BackendApiClients(this.config.openfortAPIConfig);
         this.authManager = new AuthManager(this.config, this.backendApiClients);
         this.instanceManager = new InstanceManager(new SessionStorage(), new LocalStorage(), new LocalStorage(), this.authManager);
+        this.openfortEventEmitter = new TypedEventEmitter();
         this.iframeManager = new IframeManager(this.config);
     }
     async logout() {
@@ -4130,6 +5586,29 @@ class Openfort {
             this.instanceManager.removeJWK();
         }
     }
+    getEthereumProvider(options = {
+        announceProvider: true,
+    }) {
+        if (!(this.signer instanceof EmbeddedSigner)) {
+            throw new EmbeddedNotConfigured('Embedded signer must be configured to get Ethereum provider');
+        }
+        const address = this.instanceManager.getAccountAddress();
+        const provider = new EvmProvider({
+            openfortEventEmitter: this.openfortEventEmitter,
+            signer: this.signer,
+            address: address,
+            instanceManager: this.instanceManager,
+            backendApiClients: this.backendApiClients,
+            policyId: options.policy,
+        });
+        if (options?.announceProvider) {
+            announceProvider({
+                info: openfortProviderInfo,
+                provider,
+            });
+        }
+        return provider;
+    }
     async flushSigner() {
         if (this.signer) {
             await this.signer.logout();