@ape.swap/bonds-sdk 1.0.27 → 1.0.29

package/src/views/Bonds/type.ts

@@ -0,0 +1,34 @@
+import { ChainId } from "@ape.swap/apeswap-lists"
+
+export interface BondsDataResponse {
+    index: number
+    cmcId?: number
+    label: string
+    chainId: ChainId
+    type: string
+    principalToken: string
+    principalTokenName: string
+    principalTokenDecimals: number
+    payoutToken: string
+    payoutTokenName: string
+    payoutTokenDecimals: number
+    discount: number
+    billAddress: string
+    billNftAddress: string
+    initTime: number
+    soldOut: boolean
+    inactive: boolean
+    trueBillPrice: string
+    maxTotalPayout: string
+    totalPayoutGiven: string
+    maxPayout: string
+    tokensRemaining: string
+    showcaseToken: string
+    showcaseTokenName: string
+    vestingTerm: number
+    principalTokenPrice: string
+    payoutTokenPrice: string
+    priceUsd: string
+    tags?: string[]
+    arr: string
+  }

package/src/views/BondsWithProvider/BondsWithProvider.tsx

@@ -0,0 +1,14 @@
+import React, { useEffect, useState } from 'react'
+import {Web3ContextProvider} from "../../wallet/provider";
+import Bonds from "../Bonds";
+
+const BondsWithProvider: React.FC = ( ) => {
+    return (
+        <Web3ContextProvider>
+            <Bonds />
+            {/*<>TEST</>*/}
+         </Web3ContextProvider>
+    )
+}
+
+export default BondsWithProvider

package/src/views/BondsWithProvider/index.ts

@@ -0,0 +1,2 @@
+export { default } from './BondsWithProvider'
+

package/src/views/index.ts

@@ -0,0 +1 @@
+// export { default as Bonds } from './Bonds'

package/src/wallet/ConnectionOptions.tsx

@@ -0,0 +1,59 @@
+import React from 'react'
+
+import { ConnectionType, getHasMetaMaskExtensionInstalled } from './connections'
+import { METAMASK_URL } from './constants'
+import { Option } from './Option'
+
+type ConnectOptionsParams = {
+  activeConnectionType: ConnectionType | null
+  isConnectionActive: boolean
+  onActivate: (connectionType: ConnectionType) => void
+  onDeactivate: (connectionType: null) => void
+}
+
+export const ConnectionOptions = ({
+  activeConnectionType,
+  isConnectionActive,
+  onActivate,
+  onDeactivate,
+}: ConnectOptionsParams) => {
+  function getOptions(isActive: boolean) {
+    const hasMetaMaskExtension = getHasMetaMaskExtensionInstalled()
+
+    const isNoOptionActive = !isActive || (isActive && activeConnectionType === null)
+
+    const metaMaskOption = hasMetaMaskExtension ? (
+      <Option
+        isEnabled={isNoOptionActive || activeConnectionType === ConnectionType.INJECTED}
+        isConnected={activeConnectionType === ConnectionType.INJECTED}
+        connectionType={ConnectionType.INJECTED}
+        onActivate={onActivate}
+        onDeactivate={onDeactivate}
+      />
+    ) : (
+      <a href={METAMASK_URL}>
+        <button>Install Metamask</button>
+      </a>
+    )
+
+
+    const walletConnectOption = (
+      <Option
+        isEnabled={isNoOptionActive || activeConnectionType === ConnectionType.WALLET_CONNECT}
+        isConnected={activeConnectionType === ConnectionType.WALLET_CONNECT}
+        connectionType={ConnectionType.WALLET_CONNECT}
+        onActivate={onActivate}
+        onDeactivate={onDeactivate}
+      />
+    )
+
+    return (
+      <>
+        {metaMaskOption}
+        {walletConnectOption}
+      </>
+    )
+  }
+
+  return <div className="connectors">{getOptions(isConnectionActive)}</div>
+}

package/src/wallet/Option.tsx

@@ -0,0 +1,44 @@
+import React from 'react'
+
+import { ConnectionType, getConnection, tryActivateConnector, tryDeactivateConnector } from './connections'
+
+export const Option = ({
+  isEnabled,
+  isConnected,
+  connectionType,
+  onActivate,
+  onDeactivate,
+}: {
+  isEnabled: boolean
+  isConnected: boolean
+  connectionType: ConnectionType
+  onActivate: (connectionType: ConnectionType) => void
+  onDeactivate: (connectionType: null) => void
+}) => {
+  const onClick = async () => {
+    if (isConnected) {
+      const deactivation = await tryDeactivateConnector(getConnection(connectionType).connector)
+      // undefined means the deactivation failed
+      if (deactivation === undefined) {
+        return
+      }
+      onDeactivate(deactivation)
+      return
+    }
+
+    const activation = await tryActivateConnector(getConnection(connectionType).connector)
+    if (!activation) {
+      return
+    }
+    onActivate(activation)
+    return
+  }
+
+  return (
+    <div>
+      <button onClick={onClick} disabled={!isEnabled}>{`${
+        isConnected ? 'Disconnect' : 'Connect'
+      } ${connectionType}`}</button>
+    </div>
+  )
+}

package/src/wallet/config.ts

@@ -0,0 +1,23 @@
+// Sets if the example should run locally or on chain
+export enum Chain {
+  POLYGON,
+  MAINNET,
+}
+
+// Inputs that configure this example to run
+interface ExampleConfig {
+  chain: Chain
+  rpc: {
+    polygon: string
+    mainnet: string
+  }
+}
+
+// Example Configuration
+export const CurrentConfig: ExampleConfig = {
+  chain: Chain.MAINNET,
+  rpc: {
+    polygon: '',
+    mainnet: '',
+  },
+}

package/src/wallet/connections.ts

@@ -0,0 +1,92 @@
+import { Web3ReactHooks } from '@web3-react/core'
+import { AddEthereumChainParameter, Connector } from '@web3-react/types'
+
+import { CHAIN_INFO } from './constants'
+import { buildInjectedConnector } from './injected'
+import { buildNetworkConnector } from './network'
+import { buildWalletConnectConnector } from './wallet-connect'
+
+export interface Connection {
+  connector: Connector
+  hooks: Web3ReactHooks
+  type: ConnectionType
+}
+
+export enum ConnectionType {
+  INJECTED = 'INJECTED',
+  NETWORK = 'NETWORK',
+  WALLET_CONNECT = 'WALLET_CONNECT',
+}
+
+// function getIsBraveWallet(): boolean {
+//   return window.ethereum?.isBraveWallet ?? false
+// }
+
+export function getHasMetaMaskExtensionInstalled(): boolean {
+  return (window.ethereum?.isMetaMask ?? false)
+      // && !getIsBraveWallet()
+}
+
+export function onConnectionError(error: Error) {
+  console.debug(`web3-react error: ${error}`)
+}
+
+export const PRIORITIZED_CONNECTORS: { [key in ConnectionType]: Connection } = {
+  [ConnectionType.INJECTED]: buildInjectedConnector(),
+  [ConnectionType.WALLET_CONNECT]: buildWalletConnectConnector(),
+  [ConnectionType.NETWORK]: buildNetworkConnector(),
+}
+
+export function getConnection(c: Connector | ConnectionType) {
+  if (c instanceof Connector) {
+    const connection = Object.values(PRIORITIZED_CONNECTORS).find((connection) => connection.connector === c)
+    if (!connection) {
+      throw Error('Unsupported Connector')
+    }
+    return connection
+  } else {
+    switch (c) {
+      case ConnectionType.INJECTED:
+        return PRIORITIZED_CONNECTORS[ConnectionType.INJECTED]
+      case ConnectionType.WALLET_CONNECT:
+        return PRIORITIZED_CONNECTORS[ConnectionType.WALLET_CONNECT]
+      case ConnectionType.NETWORK:
+        return PRIORITIZED_CONNECTORS[ConnectionType.NETWORK]
+    }
+  }
+}
+
+export const switchNetwork = async (chainId: number, connectionType: ConnectionType | null) => {
+  if (!connectionType) {
+    return
+  }
+
+  const { connector } = getConnection(connectionType)
+
+  if (connectionType === ConnectionType.WALLET_CONNECT || connectionType === ConnectionType.NETWORK) {
+    await connector.activate(chainId)
+    return
+  }
+
+  const chainInfo = CHAIN_INFO[chainId]
+  const addChainParameter: AddEthereumChainParameter = {
+    chainId,
+    chainName: chainInfo.label,
+    rpcUrls: [chainInfo.rpcUrl],
+    nativeCurrency: chainInfo.nativeCurrency,
+    blockExplorerUrls: [chainInfo.explorer],
+  }
+  await connector.activate(addChainParameter)
+}
+
+export const tryActivateConnector = async (connector: Connector): Promise<ConnectionType | undefined> => {
+  await connector.activate()
+  const connectionType = getConnection(connector).type
+  return connectionType
+}
+
+export const tryDeactivateConnector = async (connector: Connector): Promise<null | undefined> => {
+  connector.deactivate?.()
+  connector.resetState()
+  return null
+}

package/src/wallet/constants.ts

@@ -0,0 +1,43 @@
+import { Chain, CurrentConfig } from './config'
+
+// Chains
+const MAINNET_CHAIN_ID = 1
+const POLYGON_CHAIN_ID = 137
+
+export const INPUT_CHAIN_ID = CurrentConfig.chain === Chain.POLYGON ? POLYGON_CHAIN_ID : MAINNET_CHAIN_ID
+export const INPUT_CHAIN_URL =
+  CurrentConfig.chain === Chain.POLYGON ? CurrentConfig.rpc.polygon : CurrentConfig.rpc.mainnet
+
+export const CHAIN_TO_URL_MAP = {
+  [POLYGON_CHAIN_ID]: CurrentConfig.rpc.polygon,
+  [MAINNET_CHAIN_ID]: CurrentConfig.rpc.mainnet,
+}
+
+type ChainInfo = {
+  explorer: string
+  label: string
+  nativeCurrency: {
+    name: string
+    symbol: string
+    decimals: 18
+  }
+  rpcUrl: string
+}
+
+export const CHAIN_INFO: { [key: string]: ChainInfo } = {
+  [MAINNET_CHAIN_ID]: {
+    explorer: 'https://etherscan.io/',
+    label: 'Ethereum',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrl: CurrentConfig.rpc.mainnet,
+  },
+  [POLYGON_CHAIN_ID]: {
+    explorer: 'https://polygonscan.com/',
+    label: 'Polygon',
+    nativeCurrency: { name: 'Polygon Matic', symbol: 'MATIC', decimals: 18 },
+    rpcUrl: CurrentConfig.rpc.polygon,
+  },
+}
+
+// URLs
+export const METAMASK_URL = 'https://metamask.io/'

package/src/wallet/injected.ts

@@ -0,0 +1,17 @@
+import { initializeConnector } from '@web3-react/core'
+import { MetaMask } from '@web3-react/metamask'
+
+import { Connection, ConnectionType, onConnectionError } from './connections'
+
+export function buildInjectedConnector() {
+  const [web3MetamaskWallet, web3MetamaskWalletHooks] = initializeConnector<MetaMask>(
+    (actions) => new MetaMask({ actions, onError: onConnectionError })
+  )
+  const injectedConnection: Connection = {
+    connector: web3MetamaskWallet,
+    hooks: web3MetamaskWalletHooks,
+    type: ConnectionType.INJECTED,
+  }
+
+  return injectedConnection
+}

package/src/wallet/network.ts

@@ -0,0 +1,23 @@
+import { initializeConnector } from '@web3-react/core'
+import { Network } from '@web3-react/network'
+
+import { Connection, ConnectionType } from './connections'
+import { CHAIN_TO_URL_MAP, INPUT_CHAIN_ID } from './constants'
+
+export function buildNetworkConnector() {
+  const [web3Network, web3NetworkHooks] = initializeConnector<Network>(
+    (actions) =>
+      new Network({
+        actions,
+        urlMap: CHAIN_TO_URL_MAP,
+        defaultChainId: INPUT_CHAIN_ID,
+      })
+  )
+  const networkConnection: Connection = {
+    connector: web3Network,
+    hooks: web3NetworkHooks,
+    type: ConnectionType.NETWORK,
+  }
+
+  return networkConnection
+}

package/src/wallet/provider.tsx

@@ -0,0 +1,35 @@
+// src/wallet/provider.tsx
+import { Web3ReactProvider } from '@web3-react/core';
+import { Connector } from '@web3-react/types';
+import React, { ReactNode, useEffect } from 'react';
+import { ConnectionType, getConnection, PRIORITIZED_CONNECTORS } from './connections';
+
+async function connect(connector: Connector) {
+    try {
+        if (connector.connectEagerly) {
+            await connector.connectEagerly();
+        } else {
+            await connector.activate();
+        }
+    } catch (error) {
+        console.debug(`web3-react eager connection error: ${error}`);
+    }
+}
+
+const connectEagerly = async () => {
+    await connect(getConnection(ConnectionType.NETWORK).connector);
+};
+
+export const Web3ContextProvider = ({ children }: { children: ReactNode }) => {
+    useEffect(() => {
+        connectEagerly();
+    }, []);
+
+    return (
+        <Web3ReactProvider
+            connectors={Object.values(PRIORITIZED_CONNECTORS).map((connector) => [connector.connector, connector.hooks])}
+        >
+            {children}
+        </Web3ReactProvider>
+    );
+};

package/src/wallet/wallet-connect.ts

@@ -0,0 +1,25 @@
+import { initializeConnector } from '@web3-react/core'
+import { WalletConnect } from '@web3-react/walletconnect'
+
+import { Connection, ConnectionType, onConnectionError } from './connections'
+import { CHAIN_TO_URL_MAP } from './constants'
+
+export function buildWalletConnectConnector() {
+  const [web3WalletConnect, web3WalletConnectHooks] = initializeConnector<WalletConnect>(
+    (actions) =>
+      new WalletConnect({
+        actions,
+        options: {
+          rpc: CHAIN_TO_URL_MAP,
+          qrcode: true,
+        },
+        onError: onConnectionError,
+      })
+  )
+  const walletConnectConnection: Connection = {
+    connector: web3WalletConnect,
+    hooks: web3WalletConnectHooks,
+    type: ConnectionType.WALLET_CONNECT,
+  }
+  return walletConnectConnection
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "rootDir": "src",
+  },
+  "include": [
+    "src"
+  ]
+}