From 2a8be94ca33a172bee9515f24d9a1c8f8793f142 Mon Sep 17 00:00:00 2001 From: Aaron Barnard Date: Tue, 16 Nov 2021 13:36:51 +1100 Subject: [PATCH] Onboard V2 Monorepo --- .babelrc | 5 - .eslintrc.js | 18 - .prettierrc.js | 2 +- README.md | 47 +- ava.config.js | 13 + lerna.json | 6 + package.json | 109 +- packages/@types/index.d.ts | 3 + packages/common/README.md | 13 + packages/common/package.json | 24 + packages/common/src/eip-1193.ts | 174 + packages/common/src/errors.ts | 14 + packages/common/src/index.ts | 2 + packages/common/src/types.ts | 54 + packages/common/tsconfig.json | 14 + packages/core/.eslintrc.cjs | 39 + packages/core/.gitignore | 4 + packages/core/.prettierrc.js | 9 + packages/core/README.md | 0 packages/core/package.json | 48 + packages/core/rollup.config.js | 51 + packages/core/src/chain.ts | 47 + packages/core/src/connect.ts | 28 + packages/core/src/constants.ts | 6 + packages/core/src/disconnect.ts | 21 + packages/core/src/fonts.ts | 35 + packages/core/src/global.d.ts | 1 + packages/core/src/i18n/en.json | 29 + packages/core/src/i18n/index.ts | 29 + packages/core/src/icons/blocknative.js | 7 + packages/core/src/icons/close.js | 5 + packages/core/src/icons/default-app-icon.js | 7 + packages/core/src/icons/pending.js | 5 + packages/core/src/icons/success.js | 5 + packages/core/src/index.ts | 177 + packages/core/src/modules/blocknative.ts | 23 + packages/core/src/modules/index.ts | 1 + packages/core/src/provider.ts | 246 + packages/core/src/store/actions.ts | 96 + packages/core/src/store/constants.ts | 5 + packages/core/src/store/index.ts | 116 + packages/core/src/streams.ts | 71 + packages/core/src/types.ts | 175 + packages/core/src/utils.ts | 47 + packages/core/src/validation.ts | 142 + packages/core/src/views/Index.svelte | 24 + .../src/views/connect/ConnectedWallet.svelte | 139 + .../src/views/connect/ConnectingWallet.svelte | 131 + packages/core/src/views/connect/Index.svelte | 151 + .../src/views/connect/InstallWallet.svelte | 1 + .../views/connect/LoadingWalletButton.svelte | 60 + .../src/views/connect/SelectingWallet.svelte | 81 + .../core/src/views/connect/Sidebar.svelte | 138 + .../src/views/connect/WalletButton.svelte | 36 + packages/core/src/views/menu/Index.svelte | 0 packages/core/src/views/shared/Modal.svelte | 90 + .../src/views/shared/PendingStatusIcon.svelte | 30 + .../src/views/shared/SuccessStatusIcon.svelte | 38 + .../src/views/shared/WalletAppBadge.svelte | 98 + packages/core/tsconfig.json | 15 + packages/core/yarn.lock | 2054 +++ packages/demo/.gitignore | 4 + packages/demo/README.md | 15 + packages/demo/package.json | 24 + packages/demo/public/favicon.png | Bin 0 -> 3127 bytes packages/demo/public/global.css | 73 + packages/demo/public/index.html | 18 + packages/demo/rollup.config.js | 75 + packages/demo/src/App.svelte | 107 + packages/demo/src/blocknative-icon.js | 30 + packages/demo/src/main.js | 7 + packages/demo/yarn.lock | 663 + packages/injected/README.md | 81 + packages/injected/ava.config.cjs | 7 + packages/injected/package.json | 28 + packages/injected/src/constants.ts | 15 + packages/injected/src/helpers.ts | 26 + packages/injected/src/icons/alphawallet.ts | 23 + packages/injected/src/icons/atoken.ts | 24 + .../injected/src/icons/binance.ts | 4 +- .../injected/src/icons/bitpie.ts | 6 +- .../injected/src/icons/blankwallet.ts | 6 +- .../injected/src/icons/coinbase.ts | 6 +- .../injected/src/icons/dcent.ts | 6 +- .../injected/src/icons/detected.ts | 2 +- packages/injected/src/icons/frame.ts | 4 + packages/injected/src/icons/huobiwallet.ts | 11 + packages/injected/src/icons/hyperpay.ts | 4 + packages/injected/src/icons/imtoken.ts | 14 + packages/injected/src/icons/liquality.ts | 9 + packages/injected/src/icons/meetone.ts | 10 + packages/injected/src/icons/metamask.ts | 61 + packages/injected/src/icons/mykey.ts | 10 + packages/injected/src/icons/opera.ts | 21 + packages/injected/src/icons/ownbit.ts | 15 + packages/injected/src/icons/status.ts | 1 + packages/injected/src/icons/tokenpocket.ts | 17 + packages/injected/src/icons/tp.ts | 10 + .../injected/src/icons/trust.ts | 9 +- .../injected/src/icons/walletio.ts | 12 +- packages/injected/src/icons/xdefi.ts | 8 + packages/injected/src/index.ts | 94 + packages/injected/src/validation.ts | 37 + packages/injected/src/wallets.ts | 368 + packages/injected/tests/injected.test.ts | 89 + packages/injected/tests/setup.ts | 3 + packages/injected/tsconfig.json | 14 + packages/types/README.md | 1 + packages/types/package.json | 24 + packages/types/src/index.ts | 353 + packages/types/tsconfig.json | 14 + rollup.config.js | 99 - src/@types/index.d.ts | 29 - src/components/Modal.svelte | 152 - src/components/ModalHeader.svelte | 48 - src/components/SelectedWallet.svelte | 49 - src/components/Wallets.svelte | 109 - src/constants.ts | 5 - src/elements/Branding.svelte | 116 - src/elements/Button.svelte | 69 - src/elements/IconButton.svelte | 119 - src/elements/IconDisplay.svelte | 46 - src/elements/Spinner.svelte | 68 - src/elements/walletIcon.ts | 53 - src/interfaces.ts | 577 - src/modules/check/accounts.ts | 117 - src/modules/check/balance.ts | 47 - src/modules/check/connect.ts | 48 - src/modules/check/derivation-path.ts | 248 - src/modules/check/icons.ts | 73 - src/modules/check/index.ts | 54 - src/modules/check/network.ts | 106 - src/modules/index.ts | 42 - src/modules/select/content.ts | 59 - src/modules/select/index.ts | 232 - .../select/wallet-icons/icon-alphawallet.ts | 27 - .../select/wallet-icons/icon-atoken.png | Bin 5016 -> 0 bytes .../select/wallet-icons/icon-atoken@2x.png | Bin 8975 -> 0 bytes .../select/wallet-icons/icon-authereum.png | Bin 4578 -> 0 bytes .../select/wallet-icons/icon-cobovault.png | Bin 3195 -> 0 bytes .../select/wallet-icons/icon-cobovault@2x.png | Bin 5513 -> 0 bytes .../select/wallet-icons/icon-fortmatic.ts | 15 - .../select/wallet-icons/icon-frame.png | Bin 1862 -> 0 bytes .../select/wallet-icons/icon-frame@2x.png | Bin 3950 -> 0 bytes .../select/wallet-icons/icon-gnosis.ts | 7 - .../select/wallet-icons/icon-huobiwallet.ts | 13 - .../select/wallet-icons/icon-hyperpay.png | Bin 1705 -> 0 bytes .../select/wallet-icons/icon-hyperpay@2x.png | Bin 3686 -> 0 bytes .../select/wallet-icons/icon-imtoken.ts | 16 - .../select/wallet-icons/icon-injected.ts | 8 - .../select/wallet-icons/icon-keepkey.png | Bin 16601 -> 0 bytes .../select/wallet-icons/icon-keystone.png | Bin 2724 -> 0 bytes .../select/wallet-icons/icon-keystone@2x.png | Bin 4839 -> 0 bytes .../select/wallet-icons/icon-lattice.ts | 11 - .../select/wallet-icons/icon-ledger.ts | 5 - .../select/wallet-icons/icon-liquality.png | Bin 5197 -> 0 bytes .../select/wallet-icons/icon-liquality@2x.png | Bin 12381 -> 0 bytes .../select/wallet-icons/icon-meetone.png | Bin 21554 -> 0 bytes .../select/wallet-icons/icon-metamask.png | Bin 1254 -> 0 bytes .../select/wallet-icons/icon-metamask@2x.png | Bin 2156 -> 0 bytes .../select/wallet-icons/icon-mew-wallet.ts | 26 - .../select/wallet-icons/icon-mykey.png | Bin 2210 -> 0 bytes .../select/wallet-icons/icon-mykey@2x.png | Bin 5176 -> 0 bytes .../select/wallet-icons/icon-opera-touch.png | Bin 1630 -> 0 bytes .../wallet-icons/icon-opera-touch@2x.png | Bin 2769 -> 0 bytes .../select/wallet-icons/icon-opera.png | Bin 1266 -> 0 bytes .../select/wallet-icons/icon-opera@2x.png | Bin 2159 -> 0 bytes .../select/wallet-icons/icon-ownbit.ts | 17 - .../select/wallet-icons/icon-portis.ts | 5 - .../select/wallet-icons/icon-status.ts | 7 - .../select/wallet-icons/icon-tokenpocket.png | Bin 3412 -> 0 bytes .../wallet-icons/icon-tokenpocket@2x.png | Bin 6646 -> 0 bytes src/modules/select/wallet-icons/icon-torus.ts | 8 - src/modules/select/wallet-icons/icon-tp.png | Bin 2067 -> 0 bytes .../select/wallet-icons/icon-tp@2x.png | Bin 4254 -> 0 bytes .../select/wallet-icons/icon-trezor.ts | 8 - .../wallet-icons/icon-wallet-connect.ts | 13 - .../select/wallet-icons/icon-xdefi.png | Bin 5168 -> 0 bytes .../select/wallet-icons/icon-xdefi@2x.png | Bin 7669 -> 0 bytes src/modules/select/wallets/alphawallet.ts | 76 - src/modules/select/wallets/atoken.ts | 38 - src/modules/select/wallets/authereum.ts | 61 - .../select/wallets/binance-chain-wallet.ts | 71 - src/modules/select/wallets/bitpie.ts | 42 - src/modules/select/wallets/blankwallet.ts | 43 - src/modules/select/wallets/cobovault.ts | 260 - src/modules/select/wallets/coinbase.ts | 34 - src/modules/select/wallets/dcent.ts | 43 - src/modules/select/wallets/detectedwallet.ts | 52 - src/modules/select/wallets/fortmatic.ts | 76 - src/modules/select/wallets/frame.ts | 60 - src/modules/select/wallets/gnosis.ts | 69 - src/modules/select/wallets/hd-wallet.ts | 87 - src/modules/select/wallets/huobiwallet.ts | 75 - src/modules/select/wallets/hyperpay.ts | 38 - src/modules/select/wallets/imtoken.ts | 72 - .../select/wallets/keepkey/entryModal.ts | 315 - src/modules/select/wallets/keepkey/index.ts | 419 - src/modules/select/wallets/keystone.ts | 334 - src/modules/select/wallets/lattice.ts | 266 - src/modules/select/wallets/ledger.ts | 505 - src/modules/select/wallets/liquality.ts | 39 - src/modules/select/wallets/meetone.ts | 38 - src/modules/select/wallets/metamask.ts | 49 - src/modules/select/wallets/mewwallet.ts | 73 - src/modules/select/wallets/mykey.ts | 77 - src/modules/select/wallets/opera-touch.ts | 60 - src/modules/select/wallets/opera.ts | 40 - src/modules/select/wallets/ownbit.ts | 36 - src/modules/select/wallets/portis.ts | 77 - src/modules/select/wallets/providerEngine.ts | 54 - src/modules/select/wallets/status.ts | 59 - src/modules/select/wallets/tokenpocket.ts | 38 - src/modules/select/wallets/torus.ts | 80 - src/modules/select/wallets/tp.ts | 38 - src/modules/select/wallets/trezor.ts | 443 - src/modules/select/wallets/trust.ts | 75 - src/modules/select/wallets/wallet-connect.ts | 123 - src/modules/select/wallets/wallet-io.ts | 74 - src/modules/select/wallets/wallet-link.ts | 72 - src/modules/select/wallets/xdefi.ts | 43 - src/onboard.ts | 319 - src/services.ts | 34 - src/stores.ts | 443 - src/utilities.ts | 440 - src/validation.ts | 753 - src/views/Onboard.svelte | 62 - src/views/WalletCheck.svelte | 374 - src/views/WalletSelect.svelte | 355 - svelte.config.js | 5 - trigger-demo-build.sh | 1 - tsconfig.json | 149 +- yarn.lock | 12115 ++++++---------- 233 files changed, 12249 insertions(+), 17698 deletions(-) delete mode 100644 .babelrc delete mode 100644 .eslintrc.js create mode 100644 ava.config.js create mode 100644 lerna.json create mode 100644 packages/@types/index.d.ts create mode 100644 packages/common/README.md create mode 100644 packages/common/package.json create mode 100644 packages/common/src/eip-1193.ts create mode 100644 packages/common/src/errors.ts create mode 100644 packages/common/src/index.ts create mode 100644 packages/common/src/types.ts create mode 100644 packages/common/tsconfig.json create mode 100644 packages/core/.eslintrc.cjs create mode 100644 packages/core/.gitignore create mode 100644 packages/core/.prettierrc.js create mode 100644 packages/core/README.md create mode 100644 packages/core/package.json create mode 100644 packages/core/rollup.config.js create mode 100644 packages/core/src/chain.ts create mode 100644 packages/core/src/connect.ts create mode 100644 packages/core/src/constants.ts create mode 100644 packages/core/src/disconnect.ts create mode 100644 packages/core/src/fonts.ts create mode 100644 packages/core/src/global.d.ts create mode 100644 packages/core/src/i18n/en.json create mode 100644 packages/core/src/i18n/index.ts create mode 100644 packages/core/src/icons/blocknative.js create mode 100644 packages/core/src/icons/close.js create mode 100644 packages/core/src/icons/default-app-icon.js create mode 100644 packages/core/src/icons/pending.js create mode 100644 packages/core/src/icons/success.js create mode 100644 packages/core/src/index.ts create mode 100644 packages/core/src/modules/blocknative.ts create mode 100644 packages/core/src/modules/index.ts create mode 100644 packages/core/src/provider.ts create mode 100644 packages/core/src/store/actions.ts create mode 100644 packages/core/src/store/constants.ts create mode 100644 packages/core/src/store/index.ts create mode 100644 packages/core/src/streams.ts create mode 100644 packages/core/src/types.ts create mode 100644 packages/core/src/utils.ts create mode 100644 packages/core/src/validation.ts create mode 100644 packages/core/src/views/Index.svelte create mode 100644 packages/core/src/views/connect/ConnectedWallet.svelte create mode 100644 packages/core/src/views/connect/ConnectingWallet.svelte create mode 100644 packages/core/src/views/connect/Index.svelte create mode 100644 packages/core/src/views/connect/InstallWallet.svelte create mode 100644 packages/core/src/views/connect/LoadingWalletButton.svelte create mode 100644 packages/core/src/views/connect/SelectingWallet.svelte create mode 100644 packages/core/src/views/connect/Sidebar.svelte create mode 100644 packages/core/src/views/connect/WalletButton.svelte create mode 100644 packages/core/src/views/menu/Index.svelte create mode 100644 packages/core/src/views/shared/Modal.svelte create mode 100644 packages/core/src/views/shared/PendingStatusIcon.svelte create mode 100644 packages/core/src/views/shared/SuccessStatusIcon.svelte create mode 100644 packages/core/src/views/shared/WalletAppBadge.svelte create mode 100644 packages/core/tsconfig.json create mode 100644 packages/core/yarn.lock create mode 100644 packages/demo/.gitignore create mode 100644 packages/demo/README.md create mode 100644 packages/demo/package.json create mode 100644 packages/demo/public/favicon.png create mode 100644 packages/demo/public/global.css create mode 100644 packages/demo/public/index.html create mode 100644 packages/demo/rollup.config.js create mode 100644 packages/demo/src/App.svelte create mode 100644 packages/demo/src/blocknative-icon.js create mode 100644 packages/demo/src/main.js create mode 100644 packages/demo/yarn.lock create mode 100644 packages/injected/README.md create mode 100644 packages/injected/ava.config.cjs create mode 100644 packages/injected/package.json create mode 100644 packages/injected/src/constants.ts create mode 100644 packages/injected/src/helpers.ts create mode 100644 packages/injected/src/icons/alphawallet.ts create mode 100644 packages/injected/src/icons/atoken.ts rename src/modules/select/wallet-icons/icon-binance-chain-wallet.ts => packages/injected/src/icons/binance.ts (99%) rename src/modules/select/wallet-icons/icon-bitpie.ts => packages/injected/src/icons/bitpie.ts (95%) rename src/modules/select/wallet-icons/icon-blankwallet.ts => packages/injected/src/icons/blankwallet.ts (60%) rename src/modules/select/wallet-icons/icon-coinbase.ts => packages/injected/src/icons/coinbase.ts (81%) rename src/modules/select/wallet-icons/icon-dcent.ts => packages/injected/src/icons/dcent.ts (92%) rename src/modules/select/wallet-icons/icon-detected-wallet.ts => packages/injected/src/icons/detected.ts (73%) create mode 100644 packages/injected/src/icons/frame.ts create mode 100644 packages/injected/src/icons/huobiwallet.ts create mode 100644 packages/injected/src/icons/hyperpay.ts create mode 100644 packages/injected/src/icons/imtoken.ts create mode 100644 packages/injected/src/icons/liquality.ts create mode 100644 packages/injected/src/icons/meetone.ts create mode 100644 packages/injected/src/icons/metamask.ts create mode 100644 packages/injected/src/icons/mykey.ts create mode 100644 packages/injected/src/icons/opera.ts create mode 100644 packages/injected/src/icons/ownbit.ts create mode 100644 packages/injected/src/icons/status.ts create mode 100644 packages/injected/src/icons/tokenpocket.ts create mode 100644 packages/injected/src/icons/tp.ts rename src/modules/select/wallet-icons/icon-trust.ts => packages/injected/src/icons/trust.ts (95%) rename src/modules/select/wallet-icons/icon-wallet-io.ts => packages/injected/src/icons/walletio.ts (90%) create mode 100644 packages/injected/src/icons/xdefi.ts create mode 100644 packages/injected/src/index.ts create mode 100644 packages/injected/src/validation.ts create mode 100644 packages/injected/src/wallets.ts create mode 100644 packages/injected/tests/injected.test.ts create mode 100644 packages/injected/tests/setup.ts create mode 100644 packages/injected/tsconfig.json create mode 100644 packages/types/README.md create mode 100644 packages/types/package.json create mode 100644 packages/types/src/index.ts create mode 100644 packages/types/tsconfig.json delete mode 100644 rollup.config.js delete mode 100644 src/@types/index.d.ts delete mode 100644 src/components/Modal.svelte delete mode 100644 src/components/ModalHeader.svelte delete mode 100644 src/components/SelectedWallet.svelte delete mode 100644 src/components/Wallets.svelte delete mode 100644 src/constants.ts delete mode 100644 src/elements/Branding.svelte delete mode 100644 src/elements/Button.svelte delete mode 100644 src/elements/IconButton.svelte delete mode 100644 src/elements/IconDisplay.svelte delete mode 100644 src/elements/Spinner.svelte delete mode 100644 src/elements/walletIcon.ts delete mode 100644 src/interfaces.ts delete mode 100644 src/modules/check/accounts.ts delete mode 100644 src/modules/check/balance.ts delete mode 100644 src/modules/check/connect.ts delete mode 100644 src/modules/check/derivation-path.ts delete mode 100644 src/modules/check/icons.ts delete mode 100644 src/modules/check/index.ts delete mode 100644 src/modules/check/network.ts delete mode 100644 src/modules/index.ts delete mode 100644 src/modules/select/content.ts delete mode 100644 src/modules/select/index.ts delete mode 100644 src/modules/select/wallet-icons/icon-alphawallet.ts delete mode 100644 src/modules/select/wallet-icons/icon-atoken.png delete mode 100644 src/modules/select/wallet-icons/icon-atoken@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-authereum.png delete mode 100644 src/modules/select/wallet-icons/icon-cobovault.png delete mode 100644 src/modules/select/wallet-icons/icon-cobovault@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-fortmatic.ts delete mode 100644 src/modules/select/wallet-icons/icon-frame.png delete mode 100644 src/modules/select/wallet-icons/icon-frame@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-gnosis.ts delete mode 100644 src/modules/select/wallet-icons/icon-huobiwallet.ts delete mode 100644 src/modules/select/wallet-icons/icon-hyperpay.png delete mode 100644 src/modules/select/wallet-icons/icon-hyperpay@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-imtoken.ts delete mode 100644 src/modules/select/wallet-icons/icon-injected.ts delete mode 100644 src/modules/select/wallet-icons/icon-keepkey.png delete mode 100644 src/modules/select/wallet-icons/icon-keystone.png delete mode 100644 src/modules/select/wallet-icons/icon-keystone@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-lattice.ts delete mode 100644 src/modules/select/wallet-icons/icon-ledger.ts delete mode 100644 src/modules/select/wallet-icons/icon-liquality.png delete mode 100644 src/modules/select/wallet-icons/icon-liquality@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-meetone.png delete mode 100644 src/modules/select/wallet-icons/icon-metamask.png delete mode 100644 src/modules/select/wallet-icons/icon-metamask@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-mew-wallet.ts delete mode 100755 src/modules/select/wallet-icons/icon-mykey.png delete mode 100644 src/modules/select/wallet-icons/icon-mykey@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-opera-touch.png delete mode 100644 src/modules/select/wallet-icons/icon-opera-touch@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-opera.png delete mode 100644 src/modules/select/wallet-icons/icon-opera@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-ownbit.ts delete mode 100644 src/modules/select/wallet-icons/icon-portis.ts delete mode 100644 src/modules/select/wallet-icons/icon-status.ts delete mode 100644 src/modules/select/wallet-icons/icon-tokenpocket.png delete mode 100644 src/modules/select/wallet-icons/icon-tokenpocket@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-torus.ts delete mode 100644 src/modules/select/wallet-icons/icon-tp.png delete mode 100644 src/modules/select/wallet-icons/icon-tp@2x.png delete mode 100644 src/modules/select/wallet-icons/icon-trezor.ts delete mode 100644 src/modules/select/wallet-icons/icon-wallet-connect.ts delete mode 100644 src/modules/select/wallet-icons/icon-xdefi.png delete mode 100644 src/modules/select/wallet-icons/icon-xdefi@2x.png delete mode 100644 src/modules/select/wallets/alphawallet.ts delete mode 100644 src/modules/select/wallets/atoken.ts delete mode 100644 src/modules/select/wallets/authereum.ts delete mode 100644 src/modules/select/wallets/binance-chain-wallet.ts delete mode 100644 src/modules/select/wallets/bitpie.ts delete mode 100644 src/modules/select/wallets/blankwallet.ts delete mode 100644 src/modules/select/wallets/cobovault.ts delete mode 100644 src/modules/select/wallets/coinbase.ts delete mode 100644 src/modules/select/wallets/dcent.ts delete mode 100644 src/modules/select/wallets/detectedwallet.ts delete mode 100644 src/modules/select/wallets/fortmatic.ts delete mode 100644 src/modules/select/wallets/frame.ts delete mode 100644 src/modules/select/wallets/gnosis.ts delete mode 100644 src/modules/select/wallets/hd-wallet.ts delete mode 100644 src/modules/select/wallets/huobiwallet.ts delete mode 100644 src/modules/select/wallets/hyperpay.ts delete mode 100644 src/modules/select/wallets/imtoken.ts delete mode 100644 src/modules/select/wallets/keepkey/entryModal.ts delete mode 100644 src/modules/select/wallets/keepkey/index.ts delete mode 100644 src/modules/select/wallets/keystone.ts delete mode 100644 src/modules/select/wallets/lattice.ts delete mode 100644 src/modules/select/wallets/ledger.ts delete mode 100644 src/modules/select/wallets/liquality.ts delete mode 100644 src/modules/select/wallets/meetone.ts delete mode 100644 src/modules/select/wallets/metamask.ts delete mode 100644 src/modules/select/wallets/mewwallet.ts delete mode 100644 src/modules/select/wallets/mykey.ts delete mode 100644 src/modules/select/wallets/opera-touch.ts delete mode 100644 src/modules/select/wallets/opera.ts delete mode 100644 src/modules/select/wallets/ownbit.ts delete mode 100644 src/modules/select/wallets/portis.ts delete mode 100644 src/modules/select/wallets/providerEngine.ts delete mode 100644 src/modules/select/wallets/status.ts delete mode 100644 src/modules/select/wallets/tokenpocket.ts delete mode 100644 src/modules/select/wallets/torus.ts delete mode 100644 src/modules/select/wallets/tp.ts delete mode 100644 src/modules/select/wallets/trezor.ts delete mode 100644 src/modules/select/wallets/trust.ts delete mode 100644 src/modules/select/wallets/wallet-connect.ts delete mode 100644 src/modules/select/wallets/wallet-io.ts delete mode 100644 src/modules/select/wallets/wallet-link.ts delete mode 100644 src/modules/select/wallets/xdefi.ts delete mode 100644 src/onboard.ts delete mode 100644 src/services.ts delete mode 100644 src/stores.ts delete mode 100644 src/utilities.ts delete mode 100644 src/validation.ts delete mode 100644 src/views/Onboard.svelte delete mode 100644 src/views/WalletCheck.svelte delete mode 100644 src/views/WalletSelect.svelte delete mode 100644 svelte.config.js delete mode 100755 trigger-demo-build.sh diff --git a/.babelrc b/.babelrc deleted file mode 100644 index 89554bd83..000000000 --- a/.babelrc +++ /dev/null @@ -1,5 +0,0 @@ -{ - "presets": [ - ["@babel/env", { "modules": false, "useBuiltIns": "entry", "corejs": 3 }] - ] -} diff --git a/.eslintrc.js b/.eslintrc.js deleted file mode 100644 index 74812612c..000000000 --- a/.eslintrc.js +++ /dev/null @@ -1,18 +0,0 @@ -module.exports = { - parser: '@typescript-eslint/parser', - parserOptions: { - ecmaVersion: 2020, - sourceType: 'module' - }, - extends: [ - 'plugin:@typescript-eslint/recommended', - 'prettier' - ], - - rules: { - '@typescript-eslint/no-use-before-define': 'off', - '@typescript-eslint/no-explicit-any': 'off', - '@typescript-eslint/explicit-function-return-type': 'off', - '@typescript-eslint/no-empty-function': 'off' - } -} diff --git a/.prettierrc.js b/.prettierrc.js index c62c290ec..0b25a9228 100644 --- a/.prettierrc.js +++ b/.prettierrc.js @@ -6,4 +6,4 @@ module.exports = { tabWidth: 2, arrowParens: 'avoid', svelteSortOrder: 'options-scripts-styles-markup' -} +} \ No newline at end of file diff --git a/README.md b/README.md index 47102e52c..bcc3e085d 100644 --- a/README.md +++ b/README.md @@ -1,46 +1,3 @@ -# Onboard +# WIP Branch for Onboard V2 -JavaScript library to easily onboard users to ethereum apps by enabling wallet selection, connection, wallet checks and real time state updates. - -## Install - -`npm install bnc-onboard` - -## Quick Start - -```javascript -import Onboard from 'bnc-onboard' -import Web3 from 'web3' - -// set a variable to store instantiated web3 -let web3 - -// head to blocknative.com to create a key -const BLOCKNATIVE_KEY = 'blocknative-api-key' - -// the network id that your dapp runs on -const NETWORK_ID = 1 - -// initialize onboard -const onboard = Onboard({ - dappId: BLOCKNATIVE_KEY, - networkId: NETWORK_ID, - subscriptions: { - wallet: wallet => { - // instantiate web3 when the user has selected a wallet - web3 = new Web3(wallet.provider) - console.log(`${wallet.name} connected!`) - } - } -}) - -// Prompt user to select a wallet -await onboard.walletSelect() - -// Run wallet checks to make sure that user is ready to transact -await onboard.walletCheck() -``` - -## Documentation - -For detailed documentation head to [docs.blocknative.com](https://docs.blocknative.com/onboard) +...documentation incoming diff --git a/ava.config.js b/ava.config.js new file mode 100644 index 000000000..5ee3cc11b --- /dev/null +++ b/ava.config.js @@ -0,0 +1,13 @@ +module.exports = { + files: ["tests/**.test.ts"], + ignoredByWatcher: ["dist/**/*"], + cache: true, + concurrency: 2, + typescript: { + rewritePaths: { + "src/": "dist/", + }, + compile: false, + }, + require: ["ts-node/register/transpile-only"], +}; diff --git a/lerna.json b/lerna.json new file mode 100644 index 000000000..bcdca0415 --- /dev/null +++ b/lerna.json @@ -0,0 +1,6 @@ +{ + "packages": ["packages/*"], + "npmClient": "yarn", + "useWorkspaces": true, + "version": "independent" +} diff --git a/package.json b/package.json index 96a5baa83..702b2ffc8 100644 --- a/package.json +++ b/package.json @@ -1,95 +1,32 @@ { - "name": "bnc-onboard", - "version": "1.35.4", - "description": "Onboard users to web3 by allowing them to select a wallet, get that wallet ready to transact and have access to synced wallet state.", - "keywords": [ - "ethereum", - "web3", - "blocknative", - "wallet" + "name": "core", + "private": true, + "workspaces": [ + "packages/*" ], - "main": "dist/cjs/onboard.js", - "module": "dist/esm/onboard.js", - "typings": "dist/src/onboard.d.ts", - "files": [ - "dist" - ], - "author": "Aaron Barnard ", - "repository": { - "type": "git", - "url": "https://github.com/blocknative/onboard" - }, - "license": "MIT", "scripts": { - "build": "rimraf dist && rollup -c && babel dist/cjs --out-dir dist/cjs && babel dist/esm --out-dir dist/esm", - "test": "echo \"TBD\" && exit 0", - "prepare": "npm run build", - "lint": "eslint 'src/**/*.ts' && prettier --check {'src/**/*.ts','src/**/*.svelte'}", - "lint:fix": "eslint 'src/**/*.ts' --fix", - "format": "prettier --write {'src/**/*.ts','src/**/*.svelte'}" + "build": "lerna exec yarn build", + "dev": "lerna exec --parallel -- yarn dev", + "test": "lerna exec yarn test", + "format": "prettier --write 'packages/**/*.ts'" }, "devDependencies": { - "@babel/cli": "^7.7.0", - "@babel/core": "^7.5.5", - "@babel/preset-env": "^7.5.5", - "@pyoner/svelte-ts-preprocess": "^1.2.1", - "@rollup/plugin-image": "^2.0.4", - "@rollup/plugin-json": "^4.0.0", - "@rollup/plugin-node-resolve": "^7.1.1", - "@types/node": "^13.5.1", - "@typescript-eslint/eslint-plugin": "^2.30.0", - "@typescript-eslint/parser": "^2.30.0", - "babel-plugin-external-helpers": "^6.18.0", - "eslint": "^6.8.0", - "eslint-config-prettier": "^8.3.0", - "prettier": "^2.0.5", - "prettier-plugin-svelte": "^2.2.0", - "rimraf": "^3.0.0", - "rollup": "^1.27.5", - "rollup-plugin-svelte": "^6.1.1", - "rollup-plugin-typescript2": "0.21.0", - "svelte": "^3.12.1", - "svelte-i18n": "^1.1.2-beta", - "typescript": "^3.6.4" + "@ava/typescript": "^2.0.0", + "@swc/cli": "^0.1.51", + "@swc/core": "^1.2.92", + "@types/lodash.uniqby": "^4.7.6", + "@types/node": "^16.10.3", + "ava": "^3.15.0", + "browser-env": "^3.3.0", + "lerna": "^4.0.0", + "prettier": "^2.4.1", + "prettier-plugin-svelte": "^2.4.0", + "ts-node": "^10.2.1", + "typescript": "^4.4.3", + "window": "^4.2.7" }, "dependencies": { - "@cvbb/eth-keyring": "^1.1.0", - "@ensdomains/ensjs": "^2.0.1", - "@ethereumjs/common": "^2.0.0", - "@ethereumjs/tx": "^3.0.0", - "@gnosis.pm/safe-apps-provider": "^0.5.0", - "@gnosis.pm/safe-apps-sdk": "^3.0.0", - "@keystonehq/eth-keyring": "0.9.0", - "@ledgerhq/hw-app-eth": "6.8.1", - "@ledgerhq/hw-transport-u2f": "^5.21.0", - "@ledgerhq/hw-transport-webusb": "6.7.0", - "@portis/web3": "^4.0.0", - "@shapeshiftoss/hdwallet-core": "^1.15.2", - "@shapeshiftoss/hdwallet-keepkey": "^1.15.2", - "@shapeshiftoss/hdwallet-keepkey-webusb": "^1.15.2", - "@toruslabs/torus-embed": "^1.10.11", - "@walletconnect/web3-provider": "^1.6.2", - "authereum": "^0.1.12", - "bignumber.js": "^9.0.0", - "bnc-sdk": "^3.4.1", - "bowser": "^2.10.0", - "eth-lattice-keyring": "^0.2.7", - "eth-provider": "^0.6.1", - "eth-sig-util": "^3.0.1", - "ethereumjs-tx": "^2.1.2", - "ethereumjs-util": "^7.0.3", - "fortmatic": "^2.2.1", - "hdkey": "^2.0.1", - "regenerator-runtime": "^0.13.7", - "trezor-connect": "^8.1.9", - "walletlink": "^2.2.6", - "web3-provider-engine": "^15.0.4" - }, - "resolutions": { - "authereum/web3-utils/underscore": "^1.12.1", - "authereum/ethereum-private-key-to-address/meow/trim-newlines": "^3.0.1", - "authereum/ethers/elliptic": "^6.5.3", - "@portis/web3/pocket-js-core/axios": "^0.21.1", - "@shapeshiftoss/hdwallet-keepkey/bnb-javascript-sdk-nobroadcast/axios": "^0.21.1" + "ethers": "^5.4.7", + "joi": "^17.4.2" } } diff --git a/packages/@types/index.d.ts b/packages/@types/index.d.ts new file mode 100644 index 000000000..15abe2a38 --- /dev/null +++ b/packages/@types/index.d.ts @@ -0,0 +1,3 @@ +declare module '*.png' +declare module 'window' +declare const global: typeof globalThis & { window: CustomWindow } diff --git a/packages/common/README.md b/packages/common/README.md new file mode 100644 index 000000000..96d8081fb --- /dev/null +++ b/packages/common/README.md @@ -0,0 +1,13 @@ +# @onboard/common + +Utilities and helper method common to all wallets. + +### Usage + +createEIP1193Provider + +Basic: + +```typescript + +``` diff --git a/packages/common/package.json b/packages/common/package.json new file mode 100644 index 000000000..a6085f24c --- /dev/null +++ b/packages/common/package.json @@ -0,0 +1,24 @@ +{ + "name": "@onboard/common", + "version": "0.0.1", + "description": "Resources common to all wallets", + "module": "dist/index.js", + "typings": "dist/index.d.ts", + "files": [ + "dist", + "yarn.lock" + ], + "scripts": { + "build": "tsc", + "dev": "tsc -w", + "test": "ava", + "prepare": "yarn build" + }, + "license": "MIT", + "devDependencies": { + "typescript": "^4.4.4" + }, + "dependencies": { + "@onboard/types": "^0.0.1" + } +} diff --git a/packages/common/src/eip-1193.ts b/packages/common/src/eip-1193.ts new file mode 100644 index 000000000..82288de65 --- /dev/null +++ b/packages/common/src/eip-1193.ts @@ -0,0 +1,174 @@ +import { + Balance, + ChainId, + EIP1193Provider, + ProviderAccounts, + ProviderInfo, + ProviderMessage, + SimpleEventEmitter +} from '@onboard/types' +import { EventCallback, RequestPatch } from './types' +import { ProviderRpcError } from './errors' + +/** + * Takes a provider instance along with events and requests to override and returns an EIP1193 provider + * + * ## Example: + * + * *Overriding events: * + * ```typescript + * ``` + * + * @param provider The provider to patch + * @param requestPatch An `object` with the method to patch and the implementation with which to patch + * @param events Events to patch + * @returns An EIP1193 Provider + */ +export const createEIP1193Provider = ( + provider: any, + requestPatch?: RequestPatch, + events?: Record< + keyof SimpleEventEmitter, + EventCallback | EIP1193Provider['on'] + > +): EIP1193Provider => { + let baseRequest: any + if (provider.request) { + // Copy the original request method and bind the provider context to it + baseRequest = provider.request.bind(provider) + } else if (provider.sendAsync) { + baseRequest = createRequest(provider) + } + + const request: EIP1193Provider['request'] = ({ method, params }) => { + const key = method as keyof RequestPatch + + // If the request method is set to null this indicates this method is not supported + if (requestPatch?.[key] === null) { + throw new ProviderRpcError({ + code: 4200, + message: `The Provider does not support the requested method: ${method}` + }) + } + + if (requestPatch?.[key]) { + // @ts-ignore // @TODO - Fix this type error + return requestPatch[key]?.(baseRequest, params) + } else { + return baseRequest?.({ method, params }) + } + } + provider.request = request + + patchEvents(provider, events) + + return provider +} +/** + * + * Example: + * ```typescript + * { + * // Override the listener completely + * on: () => {}, + * // Only transform the value for a particular event + * // The return value gets passed to original listener + * on: { chainChanged: (chainId) => `${chainId}` } + * } + * ``` + * @param provider + * @param events + */ +const patchEvents = ( + provider: any, + events?: Record< + keyof SimpleEventEmitter, + EventCallback | EIP1193Provider['on'] + > +) => { + if (events) { + // Override provider event implementations + Object.entries(events).forEach(([method, implementation]) => { + const eventListener: SimpleEventEmitter[ + | 'on' + | 'off' + | 'once' + | 'removeListener'] = provider[method].bind(provider) + + // Check if it is in this form - `{ on: { chainChanged: (chainId) => `${chainId}` } }` + // If it is then we need to patch the specific event + if (typeof implementation === 'object') { + // Overwrite the listener method (e.g. `on`) such that when called will create a listener + // with our value transformer + provider[method] = (( + event, + listener: ( + value: + | string + | ProviderRpcError + | ProviderInfo + | ProviderMessage + | ProviderAccounts + ) => void + ) => { + if (implementation[event]) { + // Wrap the callback value transformer in the original listener + eventListener( + event, + ( + value: + | ProviderInfo + | ProviderRpcError + | ProviderMessage + | ChainId + | ProviderAccounts + ) => { + if (value && event) { + const transformedValue = implementation?.[event]?.(value) + if (transformedValue) { + listener(transformedValue) + } else { + listener(value) + } + } + } + ) + } else { + eventListener(event, listener) + } + }) as SimpleEventEmitter['on' | 'off' | 'once' | 'removeListener'] + } else { + provider[method] = implementation + } + }) + } +} +interface JsonRpcResponse { + id: string | undefined + jsonrpc: '2.0' + method: string + result?: ProviderAccounts | Balance | ProviderAccounts | ChainId | null + error?: string +} + +const createRequest = (provider: any): EIP1193Provider['request'] => + (({ method, params }) => + new Promise((resolve, reject) => { + provider.sendAsync( + { + id: 0, + jsonrpc: '2.0', + method, + params + }, + (error: string, { result }: JsonRpcResponse) => { + if (error) { + reject(JSON.parse(error)) + } else { + if (result) { + resolve((result as any) ?? null) + } + } + } + ) + })) as EIP1193Provider['request'] diff --git a/packages/common/src/errors.ts b/packages/common/src/errors.ts new file mode 100644 index 000000000..c59f4e958 --- /dev/null +++ b/packages/common/src/errors.ts @@ -0,0 +1,14 @@ +import { ProviderRpcErrorCode } from '@onboard/types' + +export class ProviderRpcError extends Error { + message: string + code: ProviderRpcErrorCode | number + data?: unknown + + constructor(error: Pick) { + super(error.message) + this.message = error.message + this.code = error.code + this.data = error?.data + } +} diff --git a/packages/common/src/index.ts b/packages/common/src/index.ts new file mode 100644 index 000000000..e027cda5d --- /dev/null +++ b/packages/common/src/index.ts @@ -0,0 +1,2 @@ +export { ProviderRpcError } from './errors' +export { createEIP1193Provider } from './eip-1193' \ No newline at end of file diff --git a/packages/common/src/types.ts b/packages/common/src/types.ts new file mode 100644 index 000000000..eea8edc2d --- /dev/null +++ b/packages/common/src/types.ts @@ -0,0 +1,54 @@ +import { + Balance, + ChainId, + EIP1193Provider, + EIP3085Request, + EIP3326Request, + EthAccountsRequest, + EthBalanceRequest, + EthChainIdRequest, + ProviderAccounts, + ProviderInfo, + ProviderMessage, + ProviderRpcError +} from '@onboard/types' + +/** + * Types for request patching methods. Ethereum RPC request is mapped to + * the implementation that will replace the original. + * If a method is not supported set it to `null` and the appropriate error will get called. + */ +export type RequestPatch = { + eth_accounts?: + | ((request: EIP1193Provider['request']) => Promise) + | null + eth_getBalance?: + | ((request: EIP1193Provider['request']) => Promise) + | null + eth_requestAccounts?: + | ((request: EIP1193Provider['request']) => Promise) + | null + eth_chainId?: + | ((request: EIP1193Provider['request']) => Promise) + | null + wallet_switchEthereumChain?: + | (( + request: EIP1193Provider['request'], + params: EIP3085Request['params'] + ) => Promise) + | null + wallet_addEthereumChain?: + | (( + request: EIP1193Provider['request'], + params: EIP3326Request['params'] + ) => Promise) + | null +} + +export interface EventCallback { + connect?: (info: T) => ProviderInfo + disconnect?: (error: T) => ProviderRpcError + message?: (message: T) => ProviderMessage + chainChanged?: (chainId: T) => ChainId + accountsChanged?: (accounts: T) => ProviderAccounts +} diff --git a/packages/common/tsconfig.json b/packages/common/tsconfig.json new file mode 100644 index 000000000..eb2bd2951 --- /dev/null +++ b/packages/common/tsconfig.json @@ -0,0 +1,14 @@ +{ + "extends": "../../tsconfig.json", + "include": ["src/**/*"], + + "compilerOptions": { + "outDir": "dist", + "rootDir": "src", + "declarationDir": "dist", + "paths": { + "*": ["./src/*", "./node_modules/*"] + }, + "typeRoots": ["node_modules/@types"] + } +} diff --git a/packages/core/.eslintrc.cjs b/packages/core/.eslintrc.cjs new file mode 100644 index 000000000..4573577f9 --- /dev/null +++ b/packages/core/.eslintrc.cjs @@ -0,0 +1,39 @@ +module.exports = { + root: true, + parser: '@typescript-eslint/parser', + extends: [ + 'eslint:recommended', + 'plugin:@typescript-eslint/recommended', + 'prettier' + ], + plugins: ['svelte3', '@typescript-eslint'], + ignorePatterns: ['*.cjs'], + overrides: [{ files: ['*.svelte'], processor: 'svelte3/svelte3' }], + settings: { + 'svelte3/typescript': () => require('typescript') + }, + parserOptions: { + sourceType: 'module', + ecmaVersion: 2019 + }, + env: { + browser: true, + node: true, + es2017: true + }, + rules: { + '@typescript-eslint/quotes': ['error', 'single'], + '@typescript-eslint/no-case-declarations': 'off', + 'max-len': [ + 'error', + { + code: 80, + tabWidth: 2, + ignoreStrings: true, + ignoreTemplateLiterals: true + } + ], + 'object-curly-spacing': ['error', 'always'], + '@typescript-eslint/no-empty-function': 'off' + } +} diff --git a/packages/core/.gitignore b/packages/core/.gitignore new file mode 100644 index 000000000..248dc2490 --- /dev/null +++ b/packages/core/.gitignore @@ -0,0 +1,4 @@ +/node_modules/ +/dist + +.DS_Store diff --git a/packages/core/.prettierrc.js b/packages/core/.prettierrc.js new file mode 100644 index 000000000..c62c290ec --- /dev/null +++ b/packages/core/.prettierrc.js @@ -0,0 +1,9 @@ +module.exports = { + semi: false, + trailingComma: 'none', + singleQuote: true, + printWidth: 80, + tabWidth: 2, + arrowParens: 'avoid', + svelteSortOrder: 'options-scripts-styles-markup' +} diff --git a/packages/core/README.md b/packages/core/README.md new file mode 100644 index 000000000..e69de29bb diff --git a/packages/core/package.json b/packages/core/package.json new file mode 100644 index 000000000..91f56fb38 --- /dev/null +++ b/packages/core/package.json @@ -0,0 +1,48 @@ +{ + "name": "@onboard/core", + "version": "0.0.1", + "private": true, + "scripts": { + "build": "rollup -c", + "dev": "rollup -c -w", + "start": "sirv public --no-clear", + "check": "svelte-check --tsconfig ./tsconfig.json" + }, + "module": "dist/index.js", + "typings": "dist/index.d.ts", + "devDependencies": { + "@onboard/types": "^0.0.1", + "@rollup/plugin-commonjs": "^17.0.0", + "@rollup/plugin-json": "^4.1.0", + "@rollup/plugin-node-resolve": "^11.0.0", + "@rollup/plugin-replace": "^3.0.0", + "@rollup/plugin-typescript": "^8.0.0", + "@tsconfig/svelte": "^2.0.0", + "@types/lodash.merge": "^4.6.6", + "@types/lodash.partition": "^4.6.6", + "@typescript-eslint/eslint-plugin": "^4.31.1", + "@typescript-eslint/parser": "^4.31.1", + "eslint": "^7.32.0", + "eslint-config-prettier": "^8.3.0", + "eslint-plugin-svelte3": "^3.2.1", + "prettier": "^2.4.0", + "prettier-plugin-svelte": "^2.4.0", + "rollup": "^2.3.4", + "rollup-plugin-svelte": "^7.0.0", + "svelte": "^3.42.5", + "svelte-check": "^2.2.6", + "svelte-preprocess": "^4.9.4", + "tslib": "^2.0.0", + "typescript": "4.3.5" + }, + "dependencies": { + "@onboard/types": "^0.0.1", + "bnc-sdk": "^3.6.0", + "bowser": "^2.11.0", + "lodash.merge": "^4.6.2", + "lodash.partition": "^4.6.0", + "nanoid": "^3.1.30", + "rxjs": "^7.3.0", + "svelte-i18n": "^3.3.13" + } +} diff --git a/packages/core/rollup.config.js b/packages/core/rollup.config.js new file mode 100644 index 000000000..cc29f6dc9 --- /dev/null +++ b/packages/core/rollup.config.js @@ -0,0 +1,51 @@ +import svelte from 'rollup-plugin-svelte' +import commonjs from '@rollup/plugin-commonjs' +import resolve from '@rollup/plugin-node-resolve' +import replace from '@rollup/plugin-replace' +import json from '@rollup/plugin-json' +import sveltePreprocess from 'svelte-preprocess' +import typescript from '@rollup/plugin-typescript' + +const production = !process.env.ROLLUP_WATCH + +export default { + input: 'src/index.ts', + output: { + format: 'esm', + dir: 'dist/' + }, + plugins: [ + json(), + replace({ + 'process.env.NODE_ENV': JSON.stringify(production), + preventAssignment: true + }), + svelte({ + preprocess: sveltePreprocess({ sourceMap: !production }), + compilerOptions: { + dev: !production + }, + emitCss: false + }), + resolve({ + browser: true, + dedupe: ['svelte'] + }), + commonjs(), + typescript({ + sourceMap: !production, + inlineSources: !production + }) + ], + external: [ + 'ethers', + 'bnc-sdk', + 'bowser', + 'joi', + 'nanoid', + 'rxjs', + 'svelte-i18n', + 'lodash.merge', + 'lodash.partition' + ] +} diff --git a/packages/core/src/chain.ts b/packages/core/src/chain.ts new file mode 100644 index 000000000..b1590e595 --- /dev/null +++ b/packages/core/src/chain.ts @@ -0,0 +1,47 @@ +import { addNewChain, switchChain } from './provider' +import { state } from './store' + +async function setChain(chainId: string): Promise { + // @TODO - Validate chainId + const { wallets, chains } = state.get() + // validate a wallet is connected + const [wallet] = wallets + if (!wallet) { + throw new Error('A wallet must be connected before a chain can be set') + } + + // validate that chainId has been added to chains + const chain = chains.find(({ id }) => id === chainId) + if (!chain) { + throw new Error( + `Chain with chainId: ${chainId} has not been set. Try adding via the setChains method` + ) + } + + try { + await switchChain(wallet.provider, chainId) + return true + } catch (error) { + console.warn(error) + const { code } = error as { code: number } + + if (code === 4902) { + // chain has not been added to wallet + try { + addNewChain(wallet.provider, chain) + return true + } catch (error) { + // display notification to user to switch networks + } + } + + if (code === 4200) { + // method not supported + // display notification to user to switch networks + } + } + + return false +} + +export default setChain diff --git a/packages/core/src/connect.ts b/packages/core/src/connect.ts new file mode 100644 index 000000000..833631445 --- /dev/null +++ b/packages/core/src/connect.ts @@ -0,0 +1,28 @@ +import { firstValueFrom } from 'rxjs' +import { filter, withLatestFrom, pluck } from 'rxjs/operators' +import { connectWallet$, wallets$ } from './streams' +import type { ConnectOptions, WalletState } from './types' +import { validateConnectOptions } from './validation' + +async function connect(options?: ConnectOptions): Promise { + if (options) { + const error = validateConnectOptions(options) + if (error) { + throw error + } + } + + const { autoSelect } = options || { autoSelect: '' } + + connectWallet$.next({ autoSelect, inProgress: true }) + + const result$ = connectWallet$.pipe( + filter(({ inProgress }) => inProgress === false), + withLatestFrom(wallets$), + pluck(1) + ) + + return firstValueFrom(result$) +} + +export default connect diff --git a/packages/core/src/constants.ts b/packages/core/src/constants.ts new file mode 100644 index 000000000..c76a623a6 --- /dev/null +++ b/packages/core/src/constants.ts @@ -0,0 +1,6 @@ +import type { AppState } from './types' + +export const APP_INITIAL_STATE: AppState = { + wallets: [], + chains: [] +} diff --git a/packages/core/src/disconnect.ts b/packages/core/src/disconnect.ts new file mode 100644 index 000000000..7f3a3c7f7 --- /dev/null +++ b/packages/core/src/disconnect.ts @@ -0,0 +1,21 @@ +import { state } from './store' +import { removeWallet } from './store/actions' +import { disconnectWallet$ } from './streams' +import type { DisconnectOptions, WalletState } from './types' +import { validateDisconnectOptions } from './validation' + +async function disconnect(options: DisconnectOptions): Promise { + const error = validateDisconnectOptions(options) + if (error) { + throw error + } + + const { label } = options + + disconnectWallet$.next(label) + removeWallet(label) + + return state.get().wallets +} + +export default disconnect diff --git a/packages/core/src/fonts.ts b/packages/core/src/fonts.ts new file mode 100644 index 000000000..9789b2c0d --- /dev/null +++ b/packages/core/src/fonts.ts @@ -0,0 +1,35 @@ +export const SofiaProRegular = ` + @font-face { + font-family: Sofia Pro; + src: url(data:application/font-woff2;charset=utf-8;base64,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) format('woff2'), + url(data:application/font-woff;charset=utf-8;base64,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) format('woff'), + url('sofiapro-regular.ttf') format('truetype'); + font-weight: normal; + font-style: normal; + + } +` + +export const SofiaProLight = ` + @font-face { + font-family: 'Sofia Pro Light'; + src: url(data:application/font-woff2;charset=utf-8;base64,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) format('woff2'), + url(data:application/font-woff;charset=utf-8;base64,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) format('woff'), + url('sofiapro-light.ttf') format('truetype'); + font-weight: normal; + font-style: normal; + + } +` + +export const SofiaProSemiBold = ` + @font-face { + font-family: 'Sofia Pro Semibold'; + src: url(data:application/font-woff2;charset=utf-8;base64,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) format('woff2'), + url(data:application/font-woff;charset=utf-8;base64,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) format('woff'), + url('sofiapro-semibold.ttf') format('truetype'); + font-weight: normal; + font-style: normal; + + } +` diff --git a/packages/core/src/global.d.ts b/packages/core/src/global.d.ts new file mode 100644 index 000000000..0e7296906 --- /dev/null +++ b/packages/core/src/global.d.ts @@ -0,0 +1 @@ +/// \ No newline at end of file diff --git a/packages/core/src/i18n/en.json b/packages/core/src/i18n/en.json new file mode 100644 index 000000000..13f1291c1 --- /dev/null +++ b/packages/core/src/i18n/en.json @@ -0,0 +1,29 @@ +{ + "connect": { + "selectingWallet": { + "sidebar": { + "heading": "Get Started", + "subheading": "Connect your wallet", + "paragraph": "Connecting a crypto wallet is like “logging in” for an application. It will allow you to do things with the items in your wallet. Etc..." + }, + "primaryButton": "Show More" + }, + "connectingWallet": { + "sidebar": { + "subheading": "Login and Authorize Your Wallet...", + "paragraph": "This dapp requires access to your wallet, please login and authorize access to your MetaMask accounts to continue." + }, + "mainText": "Connecting...", + "primaryButton": "Back to wallets" + }, + "connectedWallet": { + "sidebar": { + "subheading": "Dapp Authorized", + "paragraph": "{dapp} is now connected to your wallet" + }, + "mainText": "Connected" + } + }, + "menu": {}, + "shared": {} +} diff --git a/packages/core/src/i18n/index.ts b/packages/core/src/i18n/index.ts new file mode 100644 index 000000000..06193e7a7 --- /dev/null +++ b/packages/core/src/i18n/index.ts @@ -0,0 +1,29 @@ +import { addMessages, init, getLocaleFromNavigator } from 'svelte-i18n' +import merge from 'lodash.merge' +import en from './en.json' +import type { i18nOptions } from '../types' + +function initialize(options?: i18nOptions): void { + if (options) { + const { en: customizedEn } = options + const merged = merge(en, customizedEn || {}) + addMessages('en', merged) + + const customLocales = Object.keys(options).filter(key => key !== 'en') + + // Sync register all customLocales + customLocales.forEach(locale => { + const dictionary = options[locale] + dictionary && addMessages(locale, dictionary) + }) + } else { + addMessages('en', en) + } + + init({ + fallbackLocale: 'en', + initialLocale: getLocaleFromNavigator() + }) +} + +export default initialize diff --git a/packages/core/src/icons/blocknative.js b/packages/core/src/icons/blocknative.js new file mode 100644 index 000000000..31d051415 --- /dev/null +++ b/packages/core/src/icons/blocknative.js @@ -0,0 +1,7 @@ +export default ` + + + + + +` diff --git a/packages/core/src/icons/close.js b/packages/core/src/icons/close.js new file mode 100644 index 000000000..ccabdec3d --- /dev/null +++ b/packages/core/src/icons/close.js @@ -0,0 +1,5 @@ +export default ` + + + +` diff --git a/packages/core/src/icons/default-app-icon.js b/packages/core/src/icons/default-app-icon.js new file mode 100644 index 000000000..d4abb9fd6 --- /dev/null +++ b/packages/core/src/icons/default-app-icon.js @@ -0,0 +1,7 @@ +export default ` + + + +` + +// @TODO - Replace this with real default icon diff --git a/packages/core/src/icons/pending.js b/packages/core/src/icons/pending.js new file mode 100644 index 000000000..6187b2276 --- /dev/null +++ b/packages/core/src/icons/pending.js @@ -0,0 +1,5 @@ +export default ` + + + +` diff --git a/packages/core/src/icons/success.js b/packages/core/src/icons/success.js new file mode 100644 index 000000000..456642ae2 --- /dev/null +++ b/packages/core/src/icons/success.js @@ -0,0 +1,5 @@ +export default ` + + + +` diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts new file mode 100644 index 000000000..352cb89a9 --- /dev/null +++ b/packages/core/src/index.ts @@ -0,0 +1,177 @@ +import type { WalletModule } from '@onboard/types' +import connectWallet from './connect' +import disconnectWallet from './disconnect' +import setChain from './chain' +import { state } from './store' +import { addChains } from './store/actions' +import { reset$, internalState$ } from './streams' +import { validateInitOptions } from './validation' +import initI18N from './i18n' + +import App from './views/Index.svelte' +import type { InitOptions, OnboardAPI } from './types' +import { getDeviceInfo } from './utils' +import { SofiaProRegular, SofiaProSemiBold, SofiaProLight } from './fonts' + +function init(options: InitOptions): OnboardAPI { + if (options) { + const error = validateInitOptions(options) + + if (error) { + throw error + } + } + + const { wallets, appMetadata = null, apiKey = null, i18n } = options + + initI18N(i18n) + + // if already initialized, need to cleanup old instance + const { svelteInstance } = internalState$.getValue() + + if (svelteInstance) { + console.warn('Re-initializing Onboard and resetting back to initial state') + svelteInstance.$destroy() + reset$.next() + } + + const device = getDeviceInfo() + + const walletModules = wallets.reduce((acc, walletInit) => { + const initialized = walletInit({ device }) + + if (initialized) { + acc.push(...(Array.isArray(initialized) ? initialized : [initialized])) + } + + return acc + }, [] as WalletModule[]) + + const app = mountApp() + + internalState$.next({ + apiKey, + appMetadata, + svelteInstance: app, + walletModules, + device, + sdkInstances: {} + }) + + return { + connectWallet, + disconnectWallet, + addChains, + setChain, + state + } +} + +function mountApp() { + class OnboardV2 extends HTMLElement { + constructor() { + super() + } + } + + customElements.define('onboard-v2', OnboardV2) + + // Add Fonts to main page + const styleEl = document.createElement('style') + + styleEl.innerHTML = ` + ${SofiaProRegular} + ${SofiaProSemiBold} + ${SofiaProLight} + ` + document.body.appendChild(styleEl) + + // add to DOM + const onboard = document.createElement('onboard-v2') + const target = onboard.attachShadow({ mode: 'open' }) + + target.innerHTML = ` + + ` + + document.body.appendChild(onboard) + + const app = new App({ + target + }) + + return app +} + +export default init diff --git a/packages/core/src/modules/blocknative.ts b/packages/core/src/modules/blocknative.ts new file mode 100644 index 000000000..1b8cea26b --- /dev/null +++ b/packages/core/src/modules/blocknative.ts @@ -0,0 +1,23 @@ +import type Blocknative from 'bnc-sdk' +import type { ChainId } from '@onboard/types' +import { internalState$ } from '../streams' + +export async function getBlocknative(chainId: ChainId): Promise { + const { sdkInstances, apiKey } = internalState$.getValue() + if (!apiKey) throw 'apiKey is needed to initialize Blocknative SDK' + + const chainIdDecimal = + typeof chainId === 'string' ? parseInt(chainId, 16) : chainId + + if (!sdkInstances[chainIdDecimal]) { + const { default: BlocknativeSDK } = await import('bnc-sdk') + + sdkInstances[chainIdDecimal] = new BlocknativeSDK({ + dappId: apiKey, + system: 'ethereum', + networkId: chainIdDecimal + }) + } + + return sdkInstances[chainIdDecimal] as Blocknative +} diff --git a/packages/core/src/modules/index.ts b/packages/core/src/modules/index.ts new file mode 100644 index 000000000..248d865db --- /dev/null +++ b/packages/core/src/modules/index.ts @@ -0,0 +1 @@ +export { getBlocknative } from './blocknative' diff --git a/packages/core/src/provider.ts b/packages/core/src/provider.ts new file mode 100644 index 000000000..c430e1db3 --- /dev/null +++ b/packages/core/src/provider.ts @@ -0,0 +1,246 @@ +import { fromEvent, Observable } from 'rxjs' +import { filter, takeUntil, withLatestFrom } from 'rxjs/operators' +import partition from 'lodash.partition' + +import type { + ChainId, + EIP1102Request, + EIP1193Provider, + ProviderAccounts +} from '@onboard/types' + +import { disconnectWallet$, wallets$ } from './streams' + +import type { Address, Balances, Chain, Ens, WalletState } from './types' +import { updateWallet } from './store/actions' +import { providers, utils } from 'ethers' +import { getRpcUrl, validEnsChain } from './utils' +import disconnect from './disconnect' +import { state } from './store' + +export function requestAccounts( + provider: EIP1193Provider +): Promise { + const args = { method: 'eth_requestAccounts' } as EIP1102Request + return provider.request(args) +} + +export function getChainId(provider: EIP1193Provider): Promise { + return provider.request({ method: 'eth_chainId' }) as Promise +} + +export function accountsChanged( + provider: EIP1193Provider, + label: WalletState['label'] +): Observable { + const disconnected$ = disconnectWallet$.pipe( + filter(wallet => wallet === label) + ) + + return fromEvent(provider, 'accountsChanged').pipe( + takeUntil(disconnected$) + ) +} + +export function chainChanged( + provider: EIP1193Provider, + label: WalletState['label'] +): Observable { + const disconnected$ = disconnectWallet$.pipe( + filter(wallet => wallet === label) + ) + + return fromEvent(provider, 'chainChanged').pipe( + takeUntil(disconnected$) + ) +} + +export function trackWallet( + provider: EIP1193Provider, + label: WalletState['label'] +): void { + accountsChanged(provider, label) + .pipe(withLatestFrom(wallets$)) + .subscribe({ + complete: () => + console.log('Removing accountsChanged listener for wallet:', label), + next: async ([[address], wallets]) => { + const { accounts, chain } = wallets.find( + wallet => wallet.label === label + ) as WalletState + + const [[existingAccount], restAccounts] = partition( + accounts, + account => account.address === address + ) + + // no address, then no account connected, so disconnect wallet + if (!address) { + disconnect({ label }) + return + } + + let account + + if (!existingAccount) { + // update accounts without ens and balance first + updateWallet(label, { + accounts: [ + { address: address, ens: null, balance: null }, + ...restAccounts + ] + }) + + const rpcUrl = getRpcUrl(chain, state.get().chains) + + if (!rpcUrl) { + console.warn('A chain with rpcUrl is required for requests') + + account = { + address: address, + ens: null, + balance: null + } + } else { + const ethersProvider = new providers.JsonRpcProvider(rpcUrl) + const { chainId } = await ethersProvider.getNetwork() + + const balanceProm = getBalance(ethersProvider, address) + const ensProm = validEnsChain(chainId.toString(16)) + ? getEns(ethersProvider, address) + : Promise.resolve(null) + + const [balance, ens] = await Promise.all([balanceProm, ensProm]) + + account = { + address, + balance, + ens + } + } + } + + const updatedOrderedAccounts = [ + existingAccount || account, + ...restAccounts + ] + + updateWallet(label, { accounts: updatedOrderedAccounts }) + } + }) + + chainChanged(provider, label) + .pipe(withLatestFrom(wallets$)) + .subscribe({ + complete: () => + console.log('Removing chainChanged listener for wallet:', label), + next: async ([chainId, wallets]) => { + const { accounts } = wallets.find( + wallet => wallet.label === label + ) as WalletState + + const resetAccounts = accounts.map(({ address }) => ({ + address, + ens: null, + balance: null + })) + + updateWallet(label, { chain: chainId, accounts: resetAccounts }) + + const rpcUrl = getRpcUrl(chainId, state.get().chains) + + if (!rpcUrl) { + console.warn('A chain with rpcUrl is required for requests') + return + } + + const ethersProvider = new providers.JsonRpcProvider(rpcUrl) + + const updatedAccounts = await Promise.all( + accounts.map(async ({ address }) => { + const balanceProm = getBalance(ethersProvider, address) + const ensProm = validEnsChain(chainId) + ? getEns(ethersProvider, address) + : Promise.resolve(null) + + const [balance, ens] = await Promise.all([balanceProm, ensProm]) + + return { + address, + balance, + ens + } + }) + ) + + // update accounts + updateWallet(label, { + accounts: updatedAccounts + }) + } + }) +} + +export async function getEns( + ethersProvider: providers.JsonRpcProvider, + address: Address +): Promise { + const name = await ethersProvider.lookupAddress(address) + let ens = null + + if (name) { + const resolver = await ethersProvider.getResolver(name) + + if (resolver) { + const contentHash = await resolver.getContentHash() + const getText = resolver.getText.bind(resolver) + + ens = { + name, + contentHash, + getText + } + } + } + + return ens +} + +export async function getBalance( + ethersProvider: providers.JsonRpcProvider, + address: string +): Promise { + const balanceWei = await ethersProvider.getBalance(address) + return balanceWei ? { eth: utils.formatEther(balanceWei) } : null +} + +export function switchChain( + provider: EIP1193Provider, + chainId: ChainId +): Promise { + return provider.request({ + method: 'wallet_switchEthereumChain', + params: [{ chainId }] + }) +} + +export function addNewChain( + provider: EIP1193Provider, + chain: Chain +): Promise { + return provider.request({ + method: 'wallet_addEthereumChain', + params: [ + { + chainId: chain.id, + chainName: chain.label, + nativeCurrency: { + name: chain.label, + symbol: chain.token, + decimals: 18 + }, + rpcUrls: [chain.rpcUrl] + } + ] + }) +} diff --git a/packages/core/src/store/actions.ts b/packages/core/src/store/actions.ts new file mode 100644 index 000000000..4f490dab1 --- /dev/null +++ b/packages/core/src/store/actions.ts @@ -0,0 +1,96 @@ +import type { + AddChainsAction, + AddWalletAction, + Chain, + RemoveWalletAction, + ResetStoreAction, + UpdateWalletAction, + WalletState +} from '../types' + +import { validateChains, validateString, validateWallet } from '../validation' + +import { + ADD_CHAINS, + UPDATE_WALLET, + RESET_STORE, + ADD_WALLET, + REMOVE_WALLET +} from './constants' +import { dispatch } from './index' + +export function addChains(chains: Chain[]): void { + const error = validateChains(chains) + + if (error) { + throw error + } + + const action = { + type: ADD_CHAINS, + payload: chains + } + + dispatch(action as AddChainsAction) +} + +export function addWallet(wallet: WalletState): void { + const error = validateWallet(wallet) + + if (error) { + console.error(error) + throw error + } + + const action = { + type: ADD_WALLET, + payload: wallet + } + + dispatch(action as AddWalletAction) +} + +export function updateWallet(id: string, update: Partial): void { + const error = validateWallet(update) + + if (error) { + console.error(error) + throw error + } + + const action = { + type: UPDATE_WALLET, + payload: { + id, + ...update + } + } + + dispatch(action as UpdateWalletAction) +} + +export function removeWallet(id: string): void { + const error = validateString(id) + + if (error) { + throw error + } + + const action = { + type: REMOVE_WALLET, + payload: { + id + } + } + + dispatch(action as RemoveWalletAction) +} + +export function resetStore(): void { + const action = { + type: RESET_STORE, + payload: null + } + + dispatch(action as ResetStoreAction) +} diff --git a/packages/core/src/store/constants.ts b/packages/core/src/store/constants.ts new file mode 100644 index 000000000..9b869077e --- /dev/null +++ b/packages/core/src/store/constants.ts @@ -0,0 +1,5 @@ +export const ADD_CHAINS = 'add_chains' +export const RESET_STORE = 'reset_store' +export const ADD_WALLET = 'add_wallet' +export const UPDATE_WALLET = 'update_wallet' +export const REMOVE_WALLET = 'remove_wallet' diff --git a/packages/core/src/store/index.ts b/packages/core/src/store/index.ts new file mode 100644 index 000000000..1de34c160 --- /dev/null +++ b/packages/core/src/store/index.ts @@ -0,0 +1,116 @@ +import { BehaviorSubject, Subject, Observable } from 'rxjs' +import { distinctUntilKeyChanged, pluck, filter } from 'rxjs/operators' + +import type { + AppState, + Chain, + WalletState, + Action, + UpdateWalletAction +} from '../types' + +import { + ADD_CHAINS, + ADD_WALLET, + UPDATE_WALLET, + REMOVE_WALLET, + RESET_STORE +} from './constants' + +import { APP_INITIAL_STATE } from '../constants' +import { notNullish } from '../utils' + +// observable to log actions or do sideeffects after every state change +export const actions$ = new Subject<{ + action: Action + state: AppState +}>() + +function reducer(state: AppState, action: Action): AppState { + const { type, payload } = action + + switch (type) { + case ADD_CHAINS: + return { + ...state, + chains: [...state.chains, ...(payload as Chain[])] + } + + case ADD_WALLET: + return { + ...state, + // add to front of wallets as it is now the primary wallet + wallets: [payload as WalletState, ...state.wallets] + } + + case UPDATE_WALLET: { + const update = payload as UpdateWalletAction['payload'] + + const updatedWallets = state.wallets.map(wallet => + wallet.label === update.id ? { ...wallet, ...update } : wallet + ) + + return { + ...state, + wallets: updatedWallets + } + } + + case REMOVE_WALLET: { + const update = payload as { id: string } + return { + ...state, + wallets: state.wallets.filter(({ label }) => label !== update.id) + } + } + + case RESET_STORE: + return APP_INITIAL_STATE + + default: + throw new Error(`Unknown type: ${type} in appStore reducer`) + } +} + +const _store = new BehaviorSubject(APP_INITIAL_STATE) +const _stateUpdates = new Subject() + +_stateUpdates.subscribe(_store) + +export function dispatch(action: Action): void { + const state = _store.getValue() + actions$.next({ action, state }) + + _stateUpdates.next(reducer(state, action)) +} + +function select(): Observable +function select(stateKey: T): Observable +function select( + stateKey?: keyof AppState +): Observable | Observable { + if (!stateKey) return _stateUpdates.asObservable() + + const validStateKeys = Object.keys(_store.getValue()) + + if (!validStateKeys.includes(String(stateKey))) { + throw new Error(`key: ${stateKey} does not exist on this store`) + } + + return _stateUpdates + .asObservable() + .pipe( + distinctUntilKeyChanged(stateKey), + pluck(stateKey), + filter(notNullish) + ) as Observable +} + +function get(): AppState { + return _store.getValue() +} + +export const state = { + select, + get +} diff --git a/packages/core/src/streams.ts b/packages/core/src/streams.ts new file mode 100644 index 000000000..8a1a61bb4 --- /dev/null +++ b/packages/core/src/streams.ts @@ -0,0 +1,71 @@ +import { Observable, Subject, defer, BehaviorSubject } from 'rxjs' +import { take, takeUntil, withLatestFrom, pluck } from 'rxjs/operators' +import { onDestroy, onMount, beforeUpdate, afterUpdate } from 'svelte' + +import { share } from 'rxjs/operators' +import { resetStore } from './store/actions' +import { state } from './store' +import type { WalletState, InternalState } from './types' + +export const reset$ = new Subject() +export const disconnectWallet$ = new Subject() + +export const internalState$ = new BehaviorSubject({ + svelteInstance: null, + walletModules: [], + apiKey: null, + appMetadata: null, + device: null, + sdkInstances: {} +}) + +export const connectWallet$ = new BehaviorSubject<{ + autoSelect?: string + inProgress: boolean +}>({ inProgress: false }) + +export const wallets$ = ( + state.select('wallets') as Observable +).pipe(share()) + +// reset logic +reset$.pipe(withLatestFrom(wallets$), pluck('1')).subscribe(wallets => { + // disconnect all wallets + wallets.forEach(({ label }) => { + disconnectWallet$.next(label) + }) + + resetStore() +}) + +export const onMount$ = defer(() => { + const subject = new Subject() + onMount(() => { + subject.next() + }) + return subject.asObservable().pipe(take(1)) +}) + +export const onDestroy$ = defer(() => { + const subject = new Subject() + onDestroy(() => { + subject.next() + }) + return subject.asObservable().pipe(take(1)) +}) + +export const afterUpdate$ = defer(() => { + const subject = new Subject() + afterUpdate(() => { + subject.next() + }) + return subject.asObservable().pipe(takeUntil(onDestroy$)) +}) + +export const beforeUpdate$ = defer(() => { + const subject = new Subject() + beforeUpdate(() => { + subject.next() + }) + return subject.asObservable().pipe(takeUntil(onDestroy$)) +}) diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts new file mode 100644 index 000000000..c622d2efa --- /dev/null +++ b/packages/core/src/types.ts @@ -0,0 +1,175 @@ +import type Blocknative from 'bnc-sdk' +import type { SvelteComponent } from 'svelte' +import type setChain from './chain' +import type connect from './connect' +import type disconnect from './disconnect' +import type { state } from './store' +import type { addChains } from './store/actions' + +import type { + Device, + WalletInit, + ChainId, + EIP1193Provider, + WalletModule +} from '@onboard/types' + +export interface InitOptions { + apiKey?: string + wallets: WalletInit[] + appMetadata?: AppMetadata + i18n?: i18nOptions +} + +export interface AppMetadata { + /* App name */ + name: string + + /* SVG icon string, with height set to 100% */ + icon: string + + /* Description of app*/ + description?: string + + /* Url to a getting started guide for app */ + gettingStartedGuide?: string + + /* Url that points to more information about app */ + explore?: string + + /** When no injected wallets detected, recommend the user to install some*/ + recommendedInjectedWallets?: RecommendedInjectedWallets[] +} + +export type RecommendedInjectedWallets = { + name: string + url: string +} + +export interface OnboardAPI { + connectWallet: typeof connect + disconnectWallet: typeof disconnect + addChains: typeof addChains + setChain: typeof setChain + state: typeof state +} +export interface ConnectOptions { + autoSelect?: string // wallet name to autoselect for user +} + +export interface DisconnectOptions { + label: string // wallet name to disconnect +} + +export interface Chain { + id: ChainId + rpcUrl: string + label?: string + token?: TokenSymbol // eg ETH, BNB, MATIC +} + +export interface WalletWithLoadedIcon + extends Omit { + icon: string +} + +export interface WalletWithLoadingIcon + extends Omit { + icon: Promise +} + +export interface RequestArguments { + method: string + params?: unknown[] | unknown +} + +export interface WalletState { + label: string // wallet name + icon: string // wallet icon svg string + provider: EIP1193Provider + accounts: Account[] + chain: Chain['id'] + instance?: unknown +} + +export type Account = { + address: Address + ens: Ens | null + balance: Balances +} + +export type Balances = Record | null + +export interface Ens { + name?: string + avatar?: string + contentHash?: string + getText?: (key: string) => Promise +} + +export type Address = string +export type TokenSymbol = string // eg ETH + +export type AddChains = (chains: Chain[]) => void +export interface OnboardActions { + addChains: AddChains +} + +export interface AppState { + chains: Chain[] + wallets: WalletState[] +} + +export type InternalState = { + svelteInstance: SvelteComponent | null + walletModules: WalletModule[] + apiKey: string | null + appMetadata: AppMetadata | null + device: Device | null + sdkInstances: { [key: number]: Blocknative | null } +} + +export type ValueOf = T[keyof T] + +export type i18nOptions = Record + +export type i18n = { + connect: { + sidebar: { + heading: string + subheading: string + paragraph: string + } + selecting: { + searchBar: string + button1: string + } + } +} + +// ==== ACTIONS ==== // +export type Action = + | AddChainsAction + | AddWalletAction + | UpdateWalletAction + | RemoveWalletAction + | ResetStoreAction + +export type AddChainsAction = { type: 'add_chains'; payload: Chain[] } + +export type AddWalletAction = { type: 'add_wallet'; payload: WalletState } + +export type UpdateWalletAction = { + type: 'update_wallet' + payload: { id: string } & Partial +} + +export type RemoveWalletAction = { + type: 'remove_wallet' + payload: { id: string } +} + +export type ResetStoreAction = { + type: 'reset_store' + payload: null +} diff --git a/packages/core/src/utils.ts b/packages/core/src/utils.ts new file mode 100644 index 000000000..4bcd39f30 --- /dev/null +++ b/packages/core/src/utils.ts @@ -0,0 +1,47 @@ +import bowser from 'bowser' + +import type { + ChainId, + Device, + DeviceBrowser, + DeviceOS, + DeviceType +} from '@onboard/types' +import type { Chain } from './types' + +export const noop = (): void => {} + +export const notNullish = (value: T | null | undefined): value is T => + value != null + +export function getDeviceInfo(): Device { + const parsed = bowser.getParser(window.navigator.userAgent) + const os = parsed.getOS() + const browser = parsed.getBrowser() + const { type } = parsed.getPlatform() + + return { + type: type as DeviceType, + os: os as DeviceOS, + browser: browser as DeviceBrowser + } +} + +export function getRpcUrl(chain: string, chains: Chain[]): string | null { + const { rpcUrl } = + chains.find(({ id }) => parseInt(id) === parseInt(chain)) || {} + + return rpcUrl || null +} + +export function validEnsChain(chainId: ChainId): boolean { + switch (chainId) { + case '0x1': + case '0x3': + case '0x4': + case '0x5': + return true + default: + return false + } +} diff --git a/packages/core/src/validation.ts b/packages/core/src/validation.ts new file mode 100644 index 000000000..6cc9d3c5e --- /dev/null +++ b/packages/core/src/validation.ts @@ -0,0 +1,142 @@ +import { + number, + string, + object, + array, + function as joiFunction, + Schema, + any, + ValidationResult +} from 'joi' + +import type { WalletModule } from '@onboard/types' + +import type { + Chain, + InitOptions, + WalletState, + ConnectOptions, + DisconnectOptions +} from './types' + +const chainId = string().pattern(/^0x[0-9a-fA-F]+$/) + +const unknownObject = object().unknown() +const address = string().pattern(/^0x[a-fA-F0-9]{40}$/) + +const chain = object({ + id: string().required(), + rpcUrl: string().required(), + label: string(), + token: string() +}) + +const ens = any().allow( + object({ + name: string().required(), + avatar: string(), + contentHash: any().allow(string(), null), + getText: joiFunction().arity(1).required() + }), + null +) + +const balance = any().allow( + object({ + eth: number() + }).unknown(), + null +) + +const account = { + address: string().required(), + ens, + balance +} + +const chains = array().items(chain) +const accounts = array().items(account) + +const wallet = object({ + label: string(), + icon: string(), + provider: unknownObject, + accounts, + chain: string(), + ens: object({ + name: string(), + avatar: string(), + contentHash: string(), + getText: joiFunction().arity(1) + }), + balance: object().pattern(/\w/, number()) +}) + +const appMetadata = object({ + name: string().required(), + description: string().required(), + icon: string().required(), + gettingStartedGuide: string(), + explore: string() +}) + +const walletModule = object({ + label: string().required(), + getInfo: joiFunction().arity(1).required(), + getInterface: joiFunction().arity(1).required() +}) + +const walletModules = array().items(joiFunction().arity(1)).required() + +const initOptions = object({ + apiKey: string(), + wallets: walletModules, + appMetadata: appMetadata +}) + +const connectOptions = object({ + autoSelect: string() +}) + +const disconnectOptions = object({ + label: string().required() +}).required() + +type ValidateReturn = ValidationResult | null + +function validate(validator: Schema, data: unknown): ValidateReturn { + const result = validator.validate(data) + return result.error ? result : null +} + +export function validateChains(data: Chain[]): ValidateReturn { + return validate(chains, data) +} + +export function validateWallet( + data: WalletState | Partial +): ValidateReturn { + return validate(wallet, data) +} + +export function validateInitOptions(data: InitOptions): ValidateReturn { + return validate(initOptions, data) +} + +export function validateWalletModule(data: WalletModule): ValidateReturn { + return validate(walletModule, data) +} + +export function validateConnectOptions(data: ConnectOptions): ValidateReturn { + return validate(connectOptions, data) +} + +export function validateDisconnectOptions( + data: DisconnectOptions +): ValidateReturn { + return validate(disconnectOptions, data) +} + +export function validateString(str: string): ValidateReturn { + return validate(string().required(), str) +} diff --git a/packages/core/src/views/Index.svelte b/packages/core/src/views/Index.svelte new file mode 100644 index 000000000..01df3d01b --- /dev/null +++ b/packages/core/src/views/Index.svelte @@ -0,0 +1,24 @@ + + + + +{#if $connectWallet$.inProgress} + +{/if} diff --git a/packages/core/src/views/connect/ConnectedWallet.svelte b/packages/core/src/views/connect/ConnectedWallet.svelte new file mode 100644 index 000000000..b3ffccd88 --- /dev/null +++ b/packages/core/src/views/connect/ConnectedWallet.svelte @@ -0,0 +1,139 @@ + + + + +
+
+
+
+ + +
+ +
+ +
+ +
+
+ +
{$_('connect.connectedWallet.mainText')}
+
+ +
+ {@html success} +
+
+
diff --git a/packages/core/src/views/connect/ConnectingWallet.svelte b/packages/core/src/views/connect/ConnectingWallet.svelte new file mode 100644 index 000000000..7a087fb88 --- /dev/null +++ b/packages/core/src/views/connect/ConnectingWallet.svelte @@ -0,0 +1,131 @@ + + + + +
+
+
+ + + + +
{$_('connect.connectingWallet.mainText')}
+
+ + + + +
+ + +
+ + diff --git a/packages/core/src/views/connect/Index.svelte b/packages/core/src/views/connect/Index.svelte new file mode 100644 index 000000000..51a553169 --- /dev/null +++ b/packages/core/src/views/connect/Index.svelte @@ -0,0 +1,151 @@ + + + + +{#if !loading} + +
+ + +
+ {#if status === 'selectingWallet'} + {#if wallets.length} + + {:else} + + {/if} + {/if} + + {#if status === 'connectingWallet'} + + {/if} + + {#if status === 'connectedWallet'} + + {/if} +
+
+
+{/if} diff --git a/packages/core/src/views/connect/InstallWallet.svelte b/packages/core/src/views/connect/InstallWallet.svelte new file mode 100644 index 000000000..534f34fad --- /dev/null +++ b/packages/core/src/views/connect/InstallWallet.svelte @@ -0,0 +1 @@ +

Install a wallet

diff --git a/packages/core/src/views/connect/LoadingWalletButton.svelte b/packages/core/src/views/connect/LoadingWalletButton.svelte new file mode 100644 index 000000000..87a1375aa --- /dev/null +++ b/packages/core/src/views/connect/LoadingWalletButton.svelte @@ -0,0 +1,60 @@ + + + + + diff --git a/packages/core/src/views/connect/SelectingWallet.svelte b/packages/core/src/views/connect/SelectingWallet.svelte new file mode 100644 index 000000000..f5344152d --- /dev/null +++ b/packages/core/src/views/connect/SelectingWallet.svelte @@ -0,0 +1,81 @@ + + + + +
+
+ {#each primaryWallets as { label, icon: iconProm, getInterface }} + {#await iconProm} + + {:then icon} + selectWallet({ label, icon, getInterface })} + /> + {/await} + {/each} + + {#if showSecondaryWallets} + {#each secondaryWallets as { label, icon: iconProm, getInterface }} + {#await iconProm} + + {:then icon} + selectWallet({ label, icon, getInterface })} + /> + {/await} + {/each} + {/if} +
+ + {#if !showSecondaryWallets && primaryWallets.length > NUM_PRIMARY_WALLETS} + + {/if} +
diff --git a/packages/core/src/views/connect/Sidebar.svelte b/packages/core/src/views/connect/Sidebar.svelte new file mode 100644 index 000000000..a0210f8b4 --- /dev/null +++ b/packages/core/src/views/connect/Sidebar.svelte @@ -0,0 +1,138 @@ + + + + +