├── README.md
├── src
    ├── declare.d.ts
    ├── react-app-env.d.ts
    ├── asset
    │   └── video
    │   │   ├── drawn.mp4
    │   │   ├── winhalos.mp4
    │   │   └── winhorns.mp4
    ├── wallet
    │   ├── index.ts
    │   ├── disconnect.tsx
    │   └── connect.tsx
    ├── setupTests.ts
    ├── pages
    │   ├── Loading.tsx
    │   ├── notify.tsx
    │   ├── solana_anchor.json
    │   └── stake.tsx
    ├── App.test.tsx
    ├── index.css
    ├── reportWebVitals.ts
    ├── index.tsx
    ├── logo.svg
    ├── App.tsx
    └── App.css
├── public
    ├── robots.txt
    ├── favicon.ico
    ├── loading.gif
    ├── loading1.gif
    ├── logo192.png
    ├── logo512.png
    ├── manifest.json
    └── index.html
├── GIT_PUSH.bat
├── .gitignore
├── tsconfig.json
└── package.json


/README.md:
--------------------------------------------------------------------------------
1 | # solana_staking_frontend


--------------------------------------------------------------------------------
/src/declare.d.ts:
--------------------------------------------------------------------------------
1 | declare module '*.mp4';


--------------------------------------------------------------------------------
/src/react-app-env.d.ts:
--------------------------------------------------------------------------------
1 | /// <reference types="react-scripts" />
2 | 


--------------------------------------------------------------------------------
/public/robots.txt:
--------------------------------------------------------------------------------
1 | # https://www.robotstxt.org/robotstxt.html
2 | User-agent: *
3 | Disallow:
4 | 


--------------------------------------------------------------------------------
/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/public/favicon.ico


--------------------------------------------------------------------------------
/public/loading.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/public/loading.gif


--------------------------------------------------------------------------------
/public/loading1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/public/loading1.gif


--------------------------------------------------------------------------------
/public/logo192.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/public/logo192.png


--------------------------------------------------------------------------------
/public/logo512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/public/logo512.png


--------------------------------------------------------------------------------
/src/asset/video/drawn.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/src/asset/video/drawn.mp4


--------------------------------------------------------------------------------
/src/asset/video/winhalos.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/src/asset/video/winhalos.mp4


--------------------------------------------------------------------------------
/src/asset/video/winhorns.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eros1006/solana_staking_frontend/HEAD/src/asset/video/winhorns.mp4


--------------------------------------------------------------------------------
/src/wallet/index.ts:
--------------------------------------------------------------------------------
1 | export { default as WalletConnect } from './connect';
2 | export { default as WalletDisconnect } from './disconnect';
3 | 


--------------------------------------------------------------------------------
/GIT_PUSH.bat:
--------------------------------------------------------------------------------
1 | git init
2 | git add .
3 | git commit -m "first commit"
4 | git branch -M main
5 | git remote add origin https://github.com/mymiracle0118/solana_staking_frontend.git
6 | git push -u origin main


--------------------------------------------------------------------------------
/src/wallet/disconnect.tsx:
--------------------------------------------------------------------------------
1 | import { WalletDisconnectButton } from '@solana/wallet-adapter-react-ui';
2 | 
3 | export default function WalletConnect(): JSX.Element {
4 |   return <WalletDisconnectButton />;
5 | }
6 | 


--------------------------------------------------------------------------------
/src/wallet/connect.tsx:
--------------------------------------------------------------------------------
1 | import { WalletMultiButton } from '@solana/wallet-adapter-react-ui';
2 | 
3 | export default function WalletConnect(): JSX.Element {
4 |   return (<>
5 |     <WalletMultiButton/>
6 |   </>
7 |   );
8 | }


--------------------------------------------------------------------------------
/src/setupTests.ts:
--------------------------------------------------------------------------------
1 | // jest-dom adds custom jest matchers for asserting on DOM nodes.
2 | // allows you to do things like:
3 | // expect(element).toHaveTextContent(/react/i)
4 | // learn more: https://github.com/testing-library/jest-dom
5 | import '@testing-library/jest-dom';
6 | 


--------------------------------------------------------------------------------
/src/pages/Loading.tsx:
--------------------------------------------------------------------------------
 1 | const Loading = ({ ...restProps }) => {
 2 | 
 3 |     return (
 4 |         <div id="load_div" {...restProps}>
 5 |             <img src="./loading.gif" className="loading" />
 6 |         </div>
 7 |     );
 8 | };
 9 | 
10 | export default Loading;
11 | 


--------------------------------------------------------------------------------
/src/App.test.tsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import { render, screen } from '@testing-library/react';
 3 | import App from './App';
 4 | 
 5 | test('renders learn react link', () => {
 6 |   render(<App />);
 7 |   const linkElement = screen.getByText(/learn react/i);
 8 |   expect(linkElement).toBeInTheDocument();
 9 | });
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # dependencies
 4 | /node_modules
 5 | /.pnp
 6 | .pnp.js
 7 | 
 8 | # testing
 9 | /coverage
10 | /build.zip
11 | 
12 | # production
13 | /build
14 | 
15 | # misc
16 | .DS_Store
17 | .env.local
18 | .env.development.local
19 | .env.test.local
20 | .env.production.local
21 | 
22 | npm-debug.log*
23 | yarn-debug.log*
24 | yarn-error.log*
25 | 


--------------------------------------------------------------------------------
/src/index.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |   margin: 0;
 3 |   font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
 4 |     'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
 5 |     sans-serif;
 6 |   -webkit-font-smoothing: antialiased;
 7 |   -moz-osx-font-smoothing: grayscale;
 8 |   background-color: #130B3C !important;
 9 | }
10 | 
11 | code {
12 |   font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
13 |     monospace;
14 | }


--------------------------------------------------------------------------------
/src/reportWebVitals.ts:
--------------------------------------------------------------------------------
 1 | import { ReportHandler } from 'web-vitals';
 2 | 
 3 | const reportWebVitals = (onPerfEntry?: ReportHandler) => {
 4 |   if (onPerfEntry && onPerfEntry instanceof Function) {
 5 |     import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
 6 |       getCLS(onPerfEntry);
 7 |       getFID(onPerfEntry);
 8 |       getFCP(onPerfEntry);
 9 |       getLCP(onPerfEntry);
10 |       getTTFB(onPerfEntry);
11 |     });
12 |   }
13 | };
14 | 
15 | export default reportWebVitals;
16 | 


--------------------------------------------------------------------------------
/src/index.tsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import ReactDOM from 'react-dom';
 3 | import './index.css';
 4 | import App from './App';
 5 | import reportWebVitals from './reportWebVitals';
 6 | 
 7 | ReactDOM.render(
 8 |   <React.StrictMode>
 9 |     <App />
10 |   </React.StrictMode>,
11 |   document.getElementById('root')
12 | );
13 | 
14 | // If you want to start measuring performance in your app, pass a function
15 | // to log results (for example: reportWebVitals(console.log))
16 | // or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
17 | reportWebVitals();
18 | 


--------------------------------------------------------------------------------
/public/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "short_name": "React App",
 3 |   "name": "Create React App Sample",
 4 |   "icons": [
 5 |     {
 6 |       "src": "favicon.ico",
 7 |       "sizes": "64x64 32x32 24x24 16x16",
 8 |       "type": "image/x-icon"
 9 |     },
10 |     {
11 |       "src": "logo192.png",
12 |       "type": "image/png",
13 |       "sizes": "192x192"
14 |     },
15 |     {
16 |       "src": "logo512.png",
17 |       "type": "image/png",
18 |       "sizes": "512x512"
19 |     }
20 |   ],
21 |   "start_url": ".",
22 |   "display": "standalone",
23 |   "theme_color": "#000000",
24 |   "background_color": "#ffffff"
25 | }
26 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es6",
 4 |     "downlevelIteration": true,
 5 |     "lib": [
 6 |       "dom",
 7 |       "dom.iterable",
 8 |       "esnext"
 9 |     ],
10 |     "allowJs": true,
11 |     "skipLibCheck": true,
12 |     "esModuleInterop": true,
13 |     "allowSyntheticDefaultImports": true,
14 |     "strict": true,
15 |     "forceConsistentCasingInFileNames": true,
16 |     "noFallthroughCasesInSwitch": true,
17 |     "module": "esnext",
18 |     "moduleResolution": "node",
19 |     "resolveJsonModule": true,
20 |     "noEmit": true,
21 |     "jsx": "react-jsx",
22 |     "isolatedModules": true
23 |   },
24 |   "include": [
25 |     "src",
26 |     "src/declare.d.ts"
27 |   ]
28 | }
29 | 


--------------------------------------------------------------------------------
/src/pages/notify.tsx:
--------------------------------------------------------------------------------
 1 | import { useSnackbar, VariantType } from 'notistack';
 2 | import { useCallback } from 'react';
 3 | 
 4 | export default function useNotify() {
 5 |   const { enqueueSnackbar } = useSnackbar();
 6 | 
 7 |   return useCallback(
 8 |     (variant: VariantType, message: string, signature?: string) => {
 9 |       enqueueSnackbar(
10 |         <span>
11 |           {message}
12 |           {signature && (
13 |             <a
14 |               rel='noreferrer'
15 |               href={`https://explorer.solana.com/tx/${signature ?? ''}?cluster=devnet`}
16 |               target='_blank'>
17 |               Transaction
18 |             </a>
19 |           )}
20 |         </span>,
21 |         { variant },
22 |       );
23 |     },
24 |     [enqueueSnackbar],
25 |   );
26 | }
27 | 


--------------------------------------------------------------------------------
/public/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8" />
 5 |     <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
 6 |     <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
 7 |     <meta name="viewport" content="width=device-width, initial-scale=1" />
 8 |     <meta name="theme-color" content="#000000" />
 9 |     <meta
10 |       name="description"
11 |       content="HvH Battle Staking"
12 |     />
13 |     <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
14 |     <!--
15 |       manifest.json provides metadata used when your web app is installed on a
16 |       user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
17 |     -->
18 |     <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
19 |     <!--
20 |       Notice the use of %PUBLIC_URL% in the tags above.
21 |       It will be replaced with the URL of the `public` folder during the build.
22 |       Only files inside the `public` folder can be referenced from the HTML.
23 | 
24 |       Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
25 |       work correctly both with client-side routing and a non-root public URL.
26 |       Learn how to configure a non-root public URL by running `npm run build`.
27 |     -->
28 |     <title>HVH Staking</title>
29 |   </head>
30 |   <body>
31 |     <noscript>You need to enable JavaScript to run this app.</noscript>
32 |     <div id="root"></div>
33 |     <!--
34 |       This HTML file is a template.
35 |       If you open it directly in the browser, you will see an empty page.
36 | 
37 |       You can add webfonts, meta tags, or analytics to this file.
38 |       The build step will place the bundled scripts into the <body> tag.
39 | 
40 |       To begin the development, run `npm start` or `yarn start`.
41 |       To create a production bundle, use `npm run build` or `yarn build`.
42 |     -->
43 |   </body>
44 | </html>
45 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "frontend",
 3 |   "version": "0.1.0",
 4 |   "private": true,
 5 |   "dependencies": {
 6 |     "@craco/craco": "^6.4.2",
 7 |     "@emotion/react": "^11.5.0",
 8 |     "@emotion/styled": "^11.3.0",
 9 |     "@headlessui/react": "^1.4.1",
10 |     "@metaplex/js": "^3.3.0",
11 |     "@mui/lab": "^5.0.0-alpha.57",
12 |     "@mui/material": "^5.0.6",
13 |     "@mui/styled-engine": "^5.2.0",
14 |     "@project-serum/anchor": "^0.18.2",
15 |     "@project-serum/sol-wallet-adapter": "^0.2.5",
16 |     "@solana/spl-token": "^0.1.8",
17 |     "@solana/spl-token-registry": "^0.2.2585",
18 |     "@solana/wallet-adapter-base": "^0.7.0",
19 |     "@solana/wallet-adapter-react": "^0.13.1",
20 |     "@solana/wallet-adapter-react-ui": "^0.6.1",
21 |     "@solana/wallet-adapter-wallets": "^0.11.3",
22 |     "@solana/wallet-base": "0.0.1",
23 |     "@solana/web3.js": "^1.31.0",
24 |     "@testing-library/jest-dom": "^5.14.1",
25 |     "@testing-library/react": "^11.2.7",
26 |     "@testing-library/user-event": "^12.8.3",
27 |     "@types/jest": "^26.0.24",
28 |     "@types/node": "^12.20.25",
29 |     "@types/react": "^17.0.22",
30 |     "@types/react-dom": "^17.0.9",
31 |     "antd": "^4.16.13",
32 |     "axios": "^0.24.0",
33 |     "bootstrap": "^5.1.1",
34 |     "borsh": "^0.6.0",
35 |     "bs58": "^4.0.1",
36 |     "buffer": "^6.0.3",
37 |     "buffer-layout": "^1.2.2",
38 |     "moment": "^2.29.1",
39 |     "mz": "^2.7.0",
40 |     "notistack": "^2.0.3",
41 |     "os": "^0.1.2",
42 |     "oyster": "^0.2.0",
43 |     "path": "^0.12.7",
44 |     "react": "^17.0.2",
45 |     "react-bootstrap": "^2.2.1",
46 |     "react-dom": "^17.0.2",
47 |     "react-icons": "^4.3.1",
48 |     "react-scripts": "4.0.3",
49 |     "typescript": "^4.4.3",
50 |     "web-vitals": "^1.1.2",
51 |     "yaml": "^1.10.2"
52 |   },
53 |   "scripts": {
54 |     "start": "react-scripts start",
55 |     "build": "react-scripts build",
56 |     "test": "react-scripts test",
57 |     "eject": "react-scripts eject"
58 |   },
59 |   "eslintConfig": {
60 |     "extends": [
61 |       "react-app",
62 |       "react-app/jest"
63 |     ]
64 |   },
65 |   "browserslist": {
66 |     "production": [
67 |       ">0.2%",
68 |       "not dead",
69 |       "not op_mini all"
70 |     ],
71 |     "development": [
72 |       "last 1 chrome version",
73 |       "last 1 firefox version",
74 |       "last 1 safari version"
75 |     ]
76 |   },
77 |   "devDependencies": {
78 |     "@types/bs58": "^4.0.1",
79 |     "@types/mz": "^2.7.4"
80 |   }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/logo.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 841.9 595.3"><g fill="#61DAFB"><path d="M666.3 296.5c0-32.5-40.7-63.3-103.1-82.4 14.4-63.6 8-114.2-20.2-130.4-6.5-3.8-14.1-5.6-22.4-5.6v22.3c4.6 0 8.3.9 11.4 2.6 13.6 7.8 19.5 37.5 14.9 75.7-1.1 9.4-2.9 19.3-5.1 29.4-19.6-4.8-41-8.5-63.5-10.9-13.5-18.5-27.5-35.3-41.6-50 32.6-30.3 63.2-46.9 84-46.9V78c-27.5 0-63.5 19.6-99.9 53.6-36.4-33.8-72.4-53.2-99.9-53.2v22.3c20.7 0 51.4 16.5 84 46.6-14 14.7-28 31.4-41.3 49.9-22.6 2.4-44 6.1-63.6 11-2.3-10-4-19.7-5.2-29-4.7-38.2 1.1-67.9 14.6-75.8 3-1.8 6.9-2.6 11.5-2.6V78.5c-8.4 0-16 1.8-22.6 5.6-28.1 16.2-34.4 66.7-19.9 130.1-62.2 19.2-102.7 49.9-102.7 82.3 0 32.5 40.7 63.3 103.1 82.4-14.4 63.6-8 114.2 20.2 130.4 6.5 3.8 14.1 5.6 22.5 5.6 27.5 0 63.5-19.6 99.9-53.6 36.4 33.8 72.4 53.2 99.9 53.2 8.4 0 16-1.8 22.6-5.6 28.1-16.2 34.4-66.7 19.9-130.1 62-19.1 102.5-49.9 102.5-82.3zm-130.2-66.7c-3.7 12.9-8.3 26.2-13.5 39.5-4.1-8-8.4-16-13.1-24-4.6-8-9.5-15.8-14.4-23.4 14.2 2.1 27.9 4.7 41 7.9zm-45.8 106.5c-7.8 13.5-15.8 26.3-24.1 38.2-14.9 1.3-30 2-45.2 2-15.1 0-30.2-.7-45-1.9-8.3-11.9-16.4-24.6-24.2-38-7.6-13.1-14.5-26.4-20.8-39.8 6.2-13.4 13.2-26.8 20.7-39.9 7.8-13.5 15.8-26.3 24.1-38.2 14.9-1.3 30-2 45.2-2 15.1 0 30.2.7 45 1.9 8.3 11.9 16.4 24.6 24.2 38 7.6 13.1 14.5 26.4 20.8 39.8-6.3 13.4-13.2 26.8-20.7 39.9zm32.3-13c5.4 13.4 10 26.8 13.8 39.8-13.1 3.2-26.9 5.9-41.2 8 4.9-7.7 9.8-15.6 14.4-23.7 4.6-8 8.9-16.1 13-24.1zM421.2 430c-9.3-9.6-18.6-20.3-27.8-32 9 .4 18.2.7 27.5.7 9.4 0 18.7-.2 27.8-.7-9 11.7-18.3 22.4-27.5 32zm-74.4-58.9c-14.2-2.1-27.9-4.7-41-7.9 3.7-12.9 8.3-26.2 13.5-39.5 4.1 8 8.4 16 13.1 24 4.7 8 9.5 15.8 14.4 23.4zM420.7 163c9.3 9.6 18.6 20.3 27.8 32-9-.4-18.2-.7-27.5-.7-9.4 0-18.7.2-27.8.7 9-11.7 18.3-22.4 27.5-32zm-74 58.9c-4.9 7.7-9.8 15.6-14.4 23.7-4.6 8-8.9 16-13 24-5.4-13.4-10-26.8-13.8-39.8 13.1-3.1 26.9-5.8 41.2-7.9zm-90.5 125.2c-35.4-15.1-58.3-34.9-58.3-50.6 0-15.7 22.9-35.6 58.3-50.6 8.6-3.7 18-7 27.7-10.1 5.7 19.6 13.2 40 22.5 60.9-9.2 20.8-16.6 41.1-22.2 60.6-9.9-3.1-19.3-6.5-28-10.2zM310 490c-13.6-7.8-19.5-37.5-14.9-75.7 1.1-9.4 2.9-19.3 5.1-29.4 19.6 4.8 41 8.5 63.5 10.9 13.5 18.5 27.5 35.3 41.6 50-32.6 30.3-63.2 46.9-84 46.9-4.5-.1-8.3-1-11.3-2.7zm237.2-76.2c4.7 38.2-1.1 67.9-14.6 75.8-3 1.8-6.9 2.6-11.5 2.6-20.7 0-51.4-16.5-84-46.6 14-14.7 28-31.4 41.3-49.9 22.6-2.4 44-6.1 63.6-11 2.3 10.1 4.1 19.8 5.2 29.1zm38.5-66.7c-8.6 3.7-18 7-27.7 10.1-5.7-19.6-13.2-40-22.5-60.9 9.2-20.8 16.6-41.1 22.2-60.6 9.9 3.1 19.3 6.5 28.1 10.2 35.4 15.1 58.3 34.9 58.3 50.6-.1 15.7-23 35.6-58.4 50.6zM320.8 78.4z"/><circle cx="420.9" cy="296.5" r="45.7"/><path d="M520.5 78.1z"/></g></svg>


--------------------------------------------------------------------------------
/src/App.tsx:
--------------------------------------------------------------------------------
 1 | import { useMemo, useState, useEffect } from "react";
 2 | import { ConnectionProvider, WalletProvider } from '@solana/wallet-adapter-react';
 3 | import { WalletModalProvider, } from '@solana/wallet-adapter-react-ui';
 4 | import { WalletAdapterNetwork } from '@solana/wallet-adapter-base';
 5 | import { SnackbarProvider } from 'notistack';
 6 | import {
 7 |     getLedgerWallet,
 8 |     getPhantomWallet,
 9 |     getSlopeWallet,
10 |     getSolflareWallet,
11 |     getSolletExtensionWallet,
12 |     getSolletWallet,
13 |     getTorusWallet,
14 | } from '@solana/wallet-adapter-wallets';
15 | import { clusterApiUrl } from '@solana/web3.js';
16 | import {WalletConnect} from './wallet'
17 | // import Mint from './pages/mint'
18 | import Stake from './pages/stake'
19 | import './bootstrap.min.css';
20 | import './App.css';
21 | import '@solana/wallet-adapter-react-ui/styles.css';
22 | import { display } from "@mui/system";
23 | 
24 | import { BsListUl } from 'react-icons/bs'; 
25 | import { BsX } from 'react-icons/bs';
26 | 
27 | export default function App(){
28 |   const network = WalletAdapterNetwork.Devnet;
29 |   const endpoint = useMemo(() => clusterApiUrl(network), [network]);
30 |   const wallets = useMemo(() => [getPhantomWallet()], []);
31 |   const [mobileLink, setMobileLink] = useState(false);
32 | 
33 |   const toggleMenu = () => {
34 |     setMobileLink(!mobileLink);
35 |   }
36 | 
37 |   return (
38 |     <ConnectionProvider endpoint={endpoint}>
39 |       <WalletProvider wallets={wallets} autoConnect>
40 |           <WalletModalProvider>
41 |             <SnackbarProvider>
42 |               <div className="container-fluid">
43 |                 <div className="header">
44 |                   <div className="logo-div">
45 |                     <a href="#">
46 |                       <img className="logo-img" src="https://glittercloudsolutions.com/wp-content/uploads/2022/03/61cb59f7b776f0f2a68c93e2_Asset-2@4x.png" alt="" loading="lazy" sizes="100vw"/>
47 |                     </a>
48 |                   </div>
49 |                   <div className="menu-div">
50 |                     {/* <button className="menu-icon"> */}
51 |                     { !mobileLink && <a href="#" onClick={toggleMenu}><BsListUl style={{width:"50px", height:"40px", color:"white", float:"right"}}/></a> }
52 |                     { mobileLink && <a href="#" onClick={toggleMenu}><BsX style={{width:"50px", height:"40px", color:"white", float:"right"}}/></a> }
53 |                     {/* </button> */}
54 |                   </div>
55 |                   <div className="header-link">
56 |                     <a href="#">
57 |                       <p>Home</p>
58 |                     </a>
59 |                     <a href="#">
60 |                       <p>About Us</p>
61 |                     </a>
62 |                     <a href="#">
63 |                       <p>Contact</p>
64 |                     </a>
65 |                   </div>
66 |                   <div className="wallet-connect">
67 |                     <WalletConnect />
68 |                   </div>
69 |                 </div>
70 |                 <div className={mobileLink ? "mobile-nav" : "d-none"}>
71 |                   <a href="#" onClick={toggleMenu}>
72 |                     <p>Home</p>
73 |                   </a>
74 |                   <a href="#" onClick={toggleMenu}>
75 |                     <p>About Us</p>
76 |                   </a>
77 |                   <a href="#" onClick={toggleMenu}>
78 |                     <p>Contact</p>
79 |                   </a>
80 |                   <div className={"mobile-walletconnect"}>
81 |                     <WalletConnect />
82 |                   </div>
83 |                 </div>
84 |                 <div className="row">
85 |                   <Stake/>
86 |                 </div>
87 |               </div>
88 |             </SnackbarProvider>
89 |           </WalletModalProvider>
90 |       </WalletProvider>
91 |     </ConnectionProvider>
92 |   );  
93 | }


--------------------------------------------------------------------------------
/src/App.css:
--------------------------------------------------------------------------------
  1 | .App {
  2 |   text-align: center;
  3 | }
  4 | 
  5 | .App-logo {
  6 |   height: 40vmin;
  7 |   pointer-events: none;
  8 | }
  9 | 
 10 | @media (prefers-reduced-motion: no-preference) {
 11 |   .App-logo {
 12 |     animation: App-logo-spin infinite 20s linear;
 13 |   }
 14 | }
 15 | 
 16 | .App-header {
 17 |   background-color: #282c34;
 18 |   min-height: 100vh;
 19 |   display: flex;
 20 |   flex-direction: column;
 21 |   align-items: center;
 22 |   justify-content: center;
 23 |   font-size: calc(10px + 2vmin);
 24 |   color: white;
 25 | }
 26 | 
 27 | .App-link {
 28 |   color: #61dafb;
 29 | }
 30 | 
 31 | @keyframes App-logo-spin {
 32 |   from {
 33 |     transform: rotate(0deg);
 34 |   }
 35 |   to {
 36 |     transform: rotate(360deg);
 37 |   }
 38 | }
 39 | 
 40 | #load_div {
 41 |   position: fixed;
 42 |   display: flex;
 43 |   flex-direction: column;
 44 |   justify-content: center;
 45 |   top: 0px;
 46 |   left: 0px;
 47 |   z-index: 10;
 48 |   width: 100vw;
 49 |   height: 100vh;
 50 |   text-align: center;
 51 |   background: white;
 52 |   opacity: 0.5;
 53 | }
 54 | 
 55 | .row {
 56 |   margin-top: 0px;
 57 |   margin-left: 0px;
 58 |   margin-right: 0px;
 59 | }
 60 | 
 61 | .loading{
 62 |   margin: auto;
 63 | }
 64 | 
 65 | .mobile-nav {
 66 |   width: 100%;
 67 |   position: absolute;
 68 |   float: none;
 69 |   left: 0px;
 70 |   top: 70px;
 71 |   background-color: #201750;
 72 | }
 73 | 
 74 | .platform-label {
 75 |   text-align: center;
 76 | }
 77 | 
 78 | .platform-label p {
 79 |   color: #00E5FF;
 80 |   font-family: "Bebas Neue";
 81 | }
 82 | 
 83 | .mobile-nav a {
 84 |   color: white;
 85 |   text-decoration: none;
 86 |   text-align: center;
 87 |   display: block;
 88 | }
 89 | 
 90 | .mobile-walletconnect {
 91 |   display: flex;
 92 |   justify-content: center;
 93 | }
 94 | 
 95 | .loading_disable{
 96 |   display: none !important;
 97 | }
 98 | 
 99 | .header {
100 |   position: fixed;
101 |   width: 100%;
102 |   display: flex;
103 |   padding: 15px;
104 |   background-color: #261c62;
105 |   justify-content: center;
106 |   left: 0px;
107 | }
108 | 
109 | .logo-div {
110 |   display: flex;
111 |   justify-content: center;
112 | }
113 | 
114 | .header-link {  
115 |   display: flex;
116 |   justify-content: center;
117 | }
118 | 
119 | .header-link a {
120 |   margin: auto;
121 |   text-decoration: none;
122 |   color: white;
123 |   /* height: 100%; */
124 |   align-content: center;
125 | }
126 | 
127 | .header-link a:hover {
128 |   color: white;
129 | }
130 | 
131 | .vs-label {
132 |   width: 100%;
133 | }
134 | 
135 | .wallet-connect {
136 |   display: flex;
137 |   justify-content: center;
138 |   align-content: center;
139 | }
140 | 
141 | .wallet-adapter-dropdown {
142 |   float: right !important;
143 |   justify-content: center;
144 | }
145 | 
146 | .wallet-adapter-button-trigger {
147 |   background-color: inherit !important;
148 | }
149 | 
150 | .wallet-adapter-button {
151 |   background-color: inherit !important;
152 | }
153 | 
154 | .flex-container {
155 |   display: flex;
156 | }
157 | 
158 | .label {
159 |   display: inline-block;
160 |   font-weight: bold;
161 |   font-family: 'Gill Sans';
162 |   margin: auto;
163 |   color: rgb(0, 0, 0);
164 | }
165 | 
166 | .winteam-label {
167 |   font-weight: bold;
168 |   font-family: 'Gill Sans';
169 |   margin: auto;
170 |   width: 100%;
171 |   text-align: center;
172 |   color: #00E5FF;
173 | }
174 | 
175 | .time-show {
176 |   font-weight: bold;
177 |   color: #00E5FF;
178 | }
179 | 
180 | .cur-time-show {
181 |   font-weight: bold;
182 |   font-style: italic;
183 |   color: #232e66;
184 |   /* display: flex; */
185 |   /* justify-content: center; */
186 | }
187 | 
188 | .cur-time-show p {
189 |   width: auto;
190 |   float: right;
191 | }
192 | 
193 | .warning-label {
194 |   color: #00E5FF;
195 |   font-weight: bold;
196 |   /* display: flex; */
197 |   /* justify-content: center; */
198 |   margin: auto;
199 |   text-align: center;
200 | }
201 | 
202 | .menu-div a {
203 |   width: 100% !important;
204 | }
205 | 
206 | .action-button {
207 |   font-family: "Roboto", lomo copy;
208 |   font-weight: 500;
209 |   fill: #FFFFFF;
210 |   color: #FFFFFF;
211 |   background-color: #30D453;
212 |   border-style: dotted;
213 | 
214 |   text-decoration: none;
215 | 
216 |   font-size: 16px;
217 |   padding: 15px 30px;
218 | 
219 |   margin: auto;
220 | }
221 | 
222 | .action-div {
223 |   text-align: center;
224 | }
225 | 
226 | .action-all-div {
227 |   margin: auto;
228 | }
229 | 
230 | .nft-div {
231 |   text-align: center;
232 | }
233 | 
234 | .nft-div p {
235 |   color: #00E5FF;
236 |   font-weight: bold;
237 | }
238 | 
239 | .nft-collection-div {
240 |   display: flex;
241 |   justify-content: center;
242 | }
243 | 
244 | .community-label {
245 |   text-align: center;
246 | }
247 | 
248 | .community-label p {
249 |   color: #00E5FF;
250 |   font-family: "Righteous", lomo copy;
251 |   font-weight: bold;
252 | }
253 | 
254 | .community-icon {
255 |   display: flex;
256 |   justify-content: center;
257 | }
258 | 
259 | .community-icon a {
260 |   width: 60px;
261 | }
262 | 
263 | .state-table {
264 |   color: #00E5FF;
265 |   /* font-family: "Righteous", lomo copy; */
266 |   font-weight: bold;
267 | }
268 | 
269 | @media only screen and (min-width: 600px) {
270 | 
271 |   .state-div {
272 |     margin-top: 50px;
273 |   }
274 | 
275 |   .action-button {
276 |     width : 180px !important;
277 |   }
278 | 
279 |   .community-icon {
280 |     margin-top: 50px;
281 |     margin-bottom: 80px;
282 |   }
283 | 
284 |   .community-label {
285 |     margin-top: 120px;
286 |   }
287 |   
288 |   .community-label p {
289 |     font-size: 50px;
290 |   }
291 | 
292 |   .nft-collection-div {
293 |     margin-top: 100px;
294 |   }
295 |   
296 |   .nft-collection-div img {
297 |     width: 300px;
298 |     height: 300px;
299 |   }
300 | 
301 |   .nft-div {
302 |     margin-top: 60px;
303 |   }
304 | 
305 |   .nft-div P {
306 |     font-size: 40px;
307 |   }
308 | 
309 |   .action-div {
310 |     height: 70px;
311 |     margin-top: 30px;
312 |   }
313 | 
314 |   .action-all-div {
315 |     /* padding: 20px; */
316 |     width: 70%;
317 |   }
318 | 
319 |   .platform-label {
320 |     margin-top: 80px;
321 |     padding-top: 0px;
322 |     padding-bottom: 50px;
323 |   }
324 | 
325 |   .platform-label p {
326 |     font-size: 70px;
327 |     font-weight: bold;
328 |   }
329 | 
330 |   .vs-label img {
331 |     width: 70%;
332 |     height: 80px;
333 |     margin: auto;
334 |   }
335 | 
336 |   .vs-video {
337 |     margin-top: 68px;
338 |   }
339 | 
340 |   .vs-video img{
341 |     width: 70%;
342 |     margin: auto;
343 |     margin-bottom: 100px;
344 |   }
345 | 
346 |   .empty-div {
347 |     height: 140px;
348 |   }
349 | 
350 |   .menu-div {
351 |     display: none;
352 |   }
353 | 
354 |   .header-link a {
355 |     font-size: 16px;
356 |   }
357 | 
358 |   .wallet-connect {
359 |     width: 40%;
360 |   }
361 | 
362 |   .header-link {
363 |     width: 40%;
364 |   }
365 | 
366 |   .logo-div {
367 |     width: 40%;
368 |   }
369 | 
370 |   .logo-img {
371 |     width: 105px;
372 |     height: 50px;
373 |   }
374 | 
375 |   .label {
376 |     font-size: 50px;
377 |   }
378 | 
379 |   .winteam-label {
380 |     margin-top: 30px;
381 |     font-size: 45px;
382 |   }
383 | 
384 |   .time-show {
385 |     font-size: 26px;
386 |   }
387 | 
388 |   .cur-time-show {
389 |     font-size: 20px;
390 |   }
391 | 
392 |   .table {
393 |     font-size: 20px;
394 |     width: 60%;
395 |     margin: auto;
396 |   }
397 | 
398 |   .claim-label {
399 |     width: 40%;
400 |     font-size: 22px;
401 |     font-weight: bold;
402 |   }
403 | 
404 |   .video-style {
405 |     width: 70%;
406 |   }
407 | 
408 |   .warning-label {
409 |     margin-top: 100px;
410 |     font-size: 25px;
411 |     width: 80%;
412 |   }
413 | 
414 |   .warning-label p {
415 |     margin-top: 20px;
416 |   }
417 | 
418 |   .stake_button {
419 |     padding: 8px 20px;
420 |     font-size: 20px;
421 |     width: 130px;
422 |     padding: 10px 0px;
423 |   }
424 | 
425 |   .unstake_button {
426 |     padding: 8px 20px;
427 |     font-size: 20px;
428 |     width: 130px;
429 |     padding: 10px 0px;
430 |   }
431 | }
432 | 
433 | @media only screen and (max-width: 574px) {
434 | 
435 |   .state-div {
436 |     margin-top: 15px;
437 |   }
438 | 
439 |   .action-button {
440 |     width : 180px !important;
441 |   }
442 | 
443 |   .community-icon {
444 |     margin-top: 30px;
445 |     margin-bottom: 50px;
446 |   }
447 | 
448 |   .community-label {
449 |     margin-top: 40px;
450 |   }
451 |   
452 |   .community-label p {
453 |     font-size: 25px;
454 |   }
455 | 
456 |   .nft-collection-div {
457 |     margin-top: 40px;
458 |   }
459 |   
460 |   .nft-collection-div img {
461 |     width: 180px;
462 |     height: 180px;
463 |   }
464 |   
465 |   .nft-div {
466 |     margin-top: 35px;
467 |   }
468 | 
469 |   .nft-div P {
470 |     font-size: 30px;
471 |   }
472 | 
473 |   .action-div {
474 |     height: 70px;
475 |     margin-top: 10px;
476 |   }
477 | 
478 |   .action-all-div {
479 |     /* padding: 20px; */
480 |     width: 70%;
481 |   }
482 | 
483 |   .platform-label {
484 |     padding-top: 0px;
485 |     padding-bottom: 40px;
486 |   }
487 | 
488 |   .platform-label p {
489 |     font-size: 35px;
490 |     font-weight: bold;
491 |   }
492 | 
493 |   .vs-label img {
494 |     width: 100%;
495 |     height: 80px;
496 |     margin: auto;
497 |   }
498 | 
499 |   .vs-video img{
500 |     width: 100%;
501 |     margin: auto;
502 |     margin-bottom: 40px;
503 |   }
504 | 
505 |    .vs-video {
506 |     margin-top: 60px;
507 |   }
508 | 
509 |   .empty-div {
510 |     height: 120px;
511 |   }
512 | 
513 |   .wallet-adapter-dropdown {
514 |     float: none !important;
515 |   }
516 | 
517 |   .menu-div {
518 |     display: contents;
519 |   }
520 | 
521 |   .header-link {
522 |     display: none;
523 |   }
524 | 
525 |   .wallet-connect {
526 |     display: none;
527 |   }
528 | 
529 |   .logo-div {
530 |     width: 50px;
531 |   }
532 | 
533 |   .logo-img {
534 |     width: 50px;
535 |     height: 35px;
536 |   }
537 | 
538 |   .label {
539 |     font-size: 16px;
540 |     font-weight: bold;
541 |   }
542 | 
543 |   .winteam-label {
544 |     margin-top: 20px;
545 |     font-size: 25px;
546 |   }
547 | 
548 |   .time-show {
549 |     font-size: 16px;
550 |     font-weight: bold;
551 |   }
552 | 
553 |   .cur-time-show {
554 |     font-size: 16px;
555 |     font-weight: bold;
556 |   }
557 | 
558 |   .table {
559 |     font-size: 20px;
560 |     width: 99%;
561 |     margin: auto;
562 |   }
563 | 
564 |   .claim-label {
565 |     width: 70%;
566 |     font-size: 16px;
567 |     font-weight: bold;
568 |   }
569 | 
570 |   .video-style {
571 |     width: 100%;
572 |   }
573 | 
574 |   .warning-label {
575 |     margin-top: 20px;
576 |     font-size: 18px;
577 |     width: 100%;
578 |   }
579 | 
580 |   .stake_button {
581 |     padding: 8px 20px;
582 |     font-size: 16px;
583 |     width: 90px;
584 |     padding: 10px 0px;
585 |   }
586 | 
587 |   .unstake_button {
588 |     padding: 8px 20px;
589 |     font-size: 16px;
590 |     width: 90px;
591 |     padding: 10px 0px;
592 |   }
593 | }
594 | 
595 | .button {
596 |   display: inline-block;
597 |   border-radius: 4px;
598 |   background-color: #008CBA;;
599 |   border: none;
600 |   color: #FFFFFF;
601 |   text-align: center;
602 |   font-size: 20px;
603 |   padding: 7px;
604 |   width: 120px;
605 |   transition: all 0.5s;
606 |   cursor: pointer;
607 |   margin: 5px;
608 | }
609 | 
610 | .button span {
611 |   cursor: pointer;
612 |   display: inline-block;
613 |   position: relative;
614 |   transition: 0.5s;
615 | }
616 | 
617 | .button span:after {
618 |   content: '\00bb';
619 |   position: absolute;
620 |   opacity: 0;
621 |   top: 0;
622 |   right: -20px;
623 |   transition: 0.5s;
624 | }
625 | 
626 | .button:hover span {
627 |   padding-right: 25px;
628 | }
629 | 
630 | .button:hover span:after {
631 |   opacity: 1;
632 |   right: 0;
633 | }
634 | 
635 | .custom-btn {
636 |   vertical-align:middle;
637 | }
638 | 
639 | .unstake_button {
640 |   background-color: #4CAF50; /* Green */
641 |   border: none;
642 |   color: rgb(238, 16, 16);
643 |   text-align: center;
644 |   text-decoration: none;
645 |   display: inline-block;
646 |   margin: 4px 2px;
647 |   transition-duration: 0.4s;
648 |   cursor: pointer;
649 |   background-color: #f4814d; 
650 |   color: black; 
651 |   border: 2px solid #ffffff;
652 | }
653 | 
654 | .unstake_button:hover {
655 |   background-color: #fccaba;
656 |   color: white;
657 | }
658 | 
659 | .stake_button {
660 |   background-color: #4CAF50; /* Green */
661 |   border: none;
662 |   color: rgb(238, 16, 16);
663 |   text-align: center;
664 |   text-decoration: none;
665 |   display: inline-block;
666 |   margin: 4px 2px;
667 |   transition-duration: 0.4s;
668 |   cursor: pointer;
669 |   background-color: #f4814d; 
670 |   color: black; 
671 |   border: 2px solid #ffffff;
672 | }
673 | 
674 | .stake_button:hover {
675 |   background-color: #fccaba;
676 |   color: white;
677 | }
678 | 
679 | .claim-label {
680 |   display: inline;
681 |   color: rgb(0, 0, 0);
682 | }
683 | 
684 | .winning-video {
685 |   display: flex;
686 |   justify-content: center;
687 | }
688 | 
689 | .video-style {
690 |   margin: auto;
691 | }


--------------------------------------------------------------------------------
/src/pages/solana_anchor.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "version": "0.1.0",
  3 |   "name": "solana_anchor",
  4 |   "instructions": [
  5 |     {
  6 |       "name": "initPool",
  7 |       "accounts": [
  8 |         {
  9 |           "name": "owner",
 10 |           "isMut": true,
 11 |           "isSigner": true
 12 |         },
 13 |         {
 14 |           "name": "pool",
 15 |           "isMut": true,
 16 |           "isSigner": false
 17 |         },
 18 |         {
 19 |           "name": "rand",
 20 |           "isMut": false,
 21 |           "isSigner": false
 22 |         },
 23 |         {
 24 |           "name": "soulsMint",
 25 |           "isMut": true,
 26 |           "isSigner": false
 27 |         },
 28 |         {
 29 |           "name": "tokenProgram",
 30 |           "isMut": false,
 31 |           "isSigner": false
 32 |         },
 33 |         {
 34 |           "name": "systemProgram",
 35 |           "isMut": false,
 36 |           "isSigner": false
 37 |         }
 38 |       ],
 39 |       "args": [
 40 |         {
 41 |           "name": "bump",
 42 |           "type": "u8"
 43 |         },
 44 |         {
 45 |           "name": "stakingPeriod",
 46 |           "type": "i64"
 47 |         },
 48 |         {
 49 |           "name": "withdrawPeriod",
 50 |           "type": "i64"
 51 |         },
 52 |         {
 53 |           "name": "hvhPercent",
 54 |           "type": "u64"
 55 |         },
 56 |         {
 57 |           "name": "soldierPercent",
 58 |           "type": "u64"
 59 |         },
 60 |         {
 61 |           "name": "winPercent",
 62 |           "type": "u64"
 63 |         },
 64 |         {
 65 |           "name": "losePercent",
 66 |           "type": "u64"
 67 |         },
 68 |         {
 69 |           "name": "burnPercent",
 70 |           "type": "u64"
 71 |         },
 72 |         {
 73 |           "name": "winTeamStake",
 74 |           "type": "u64"
 75 |         },
 76 |         {
 77 |           "name": "lostTeamStake",
 78 |           "type": "u64"
 79 |         },
 80 |         {
 81 |           "name": "tokenUnit",
 82 |           "type": "u64"
 83 |         },
 84 |         {
 85 |           "name": "soulAmount",
 86 |           "type": "u64"
 87 |         },
 88 |         {
 89 |           "name": "hvhSymbol",
 90 |           "type": "string"
 91 |         },
 92 |         {
 93 |           "name": "soldierSymbol",
 94 |           "type": "string"
 95 |         },
 96 |         {
 97 |           "name": "tokenHalos",
 98 |           "type": "string"
 99 |         },
100 |         {
101 |           "name": "tokenHorns",
102 |           "type": "string"
103 |         },
104 |         {
105 |           "name": "startTime",
106 |           "type": "i64"
107 |         },
108 |         {
109 |           "name": "period",
110 |           "type": "i64"
111 |         }
112 |       ]
113 |     },
114 |     {
115 |       "name": "initStakeState",
116 |       "accounts": [
117 |         {
118 |           "name": "owner",
119 |           "isMut": true,
120 |           "isSigner": true
121 |         },
122 |         {
123 |           "name": "pool",
124 |           "isMut": false,
125 |           "isSigner": false
126 |         },
127 |         {
128 |           "name": "soulsMint",
129 |           "isMut": false,
130 |           "isSigner": false
131 |         },
132 |         {
133 |           "name": "stakeState",
134 |           "isMut": true,
135 |           "isSigner": false
136 |         },
137 |         {
138 |           "name": "systemProgram",
139 |           "isMut": false,
140 |           "isSigner": false
141 |         }
142 |       ],
143 |       "args": [
144 |         {
145 |           "name": "bump",
146 |           "type": "u8"
147 |         }
148 |       ]
149 |     },
150 |     {
151 |       "name": "initHvhData",
152 |       "accounts": [
153 |         {
154 |           "name": "owner",
155 |           "isMut": true,
156 |           "isSigner": true
157 |         },
158 |         {
159 |           "name": "pool",
160 |           "isMut": false,
161 |           "isSigner": false
162 |         },
163 |         {
164 |           "name": "nftMint",
165 |           "isMut": false,
166 |           "isSigner": false
167 |         },
168 |         {
169 |           "name": "hvhData",
170 |           "isMut": true,
171 |           "isSigner": false
172 |         },
173 |         {
174 |           "name": "systemProgram",
175 |           "isMut": false,
176 |           "isSigner": false
177 |         }
178 |       ],
179 |       "args": [
180 |         {
181 |           "name": "bump",
182 |           "type": "u8"
183 |         }
184 |       ]
185 |     },
186 |     {
187 |       "name": "initSoldierData",
188 |       "accounts": [
189 |         {
190 |           "name": "owner",
191 |           "isMut": true,
192 |           "isSigner": true
193 |         },
194 |         {
195 |           "name": "pool",
196 |           "isMut": false,
197 |           "isSigner": false
198 |         },
199 |         {
200 |           "name": "nftMint",
201 |           "isMut": false,
202 |           "isSigner": false
203 |         },
204 |         {
205 |           "name": "soldierData",
206 |           "isMut": true,
207 |           "isSigner": false
208 |         },
209 |         {
210 |           "name": "systemProgram",
211 |           "isMut": false,
212 |           "isSigner": false
213 |         }
214 |       ],
215 |       "args": [
216 |         {
217 |           "name": "bump",
218 |           "type": "u8"
219 |         }
220 |       ]
221 |     },
222 |     {
223 |       "name": "stakehvh",
224 |       "accounts": [
225 |         {
226 |           "name": "owner",
227 |           "isMut": true,
228 |           "isSigner": true
229 |         },
230 |         {
231 |           "name": "pool",
232 |           "isMut": true,
233 |           "isSigner": false
234 |         },
235 |         {
236 |           "name": "hvhData",
237 |           "isMut": true,
238 |           "isSigner": false
239 |         },
240 |         {
241 |           "name": "stakeState",
242 |           "isMut": true,
243 |           "isSigner": false
244 |         },
245 |         {
246 |           "name": "nftMint",
247 |           "isMut": false,
248 |           "isSigner": false
249 |         },
250 |         {
251 |           "name": "metadata",
252 |           "isMut": true,
253 |           "isSigner": false
254 |         },
255 |         {
256 |           "name": "sourceNftAccount",
257 |           "isMut": true,
258 |           "isSigner": false
259 |         },
260 |         {
261 |           "name": "destNftAccount",
262 |           "isMut": true,
263 |           "isSigner": false
264 |         },
265 |         {
266 |           "name": "sourceSoulsAccount",
267 |           "isMut": true,
268 |           "isSigner": false
269 |         },
270 |         {
271 |           "name": "destSoulsAccount",
272 |           "isMut": true,
273 |           "isSigner": false
274 |         },
275 |         {
276 |           "name": "tokenProgram",
277 |           "isMut": false,
278 |           "isSigner": false
279 |         },
280 |         {
281 |           "name": "systemProgram",
282 |           "isMut": false,
283 |           "isSigner": false
284 |         },
285 |         {
286 |           "name": "clock",
287 |           "isMut": false,
288 |           "isSigner": false
289 |         }
290 |       ],
291 |       "args": [
292 |         {
293 |           "name": "hvhIdentity",
294 |           "type": "string"
295 |         }
296 |       ]
297 |     },
298 |     {
299 |       "name": "stakesoldiers",
300 |       "accounts": [
301 |         {
302 |           "name": "owner",
303 |           "isMut": true,
304 |           "isSigner": true
305 |         },
306 |         {
307 |           "name": "pool",
308 |           "isMut": true,
309 |           "isSigner": false
310 |         },
311 |         {
312 |           "name": "soldierData",
313 |           "isMut": true,
314 |           "isSigner": false
315 |         },
316 |         {
317 |           "name": "stakeState",
318 |           "isMut": true,
319 |           "isSigner": false
320 |         },
321 |         {
322 |           "name": "nftMint",
323 |           "isMut": false,
324 |           "isSigner": false
325 |         },
326 |         {
327 |           "name": "metadata",
328 |           "isMut": true,
329 |           "isSigner": false
330 |         },
331 |         {
332 |           "name": "sourceNftAccount",
333 |           "isMut": true,
334 |           "isSigner": false
335 |         },
336 |         {
337 |           "name": "destNftAccount",
338 |           "isMut": true,
339 |           "isSigner": false
340 |         },
341 |         {
342 |           "name": "sourceSoulsAccount",
343 |           "isMut": true,
344 |           "isSigner": false
345 |         },
346 |         {
347 |           "name": "destSoulsAccount",
348 |           "isMut": true,
349 |           "isSigner": false
350 |         },
351 |         {
352 |           "name": "tokenProgram",
353 |           "isMut": false,
354 |           "isSigner": false
355 |         },
356 |         {
357 |           "name": "systemProgram",
358 |           "isMut": false,
359 |           "isSigner": false
360 |         },
361 |         {
362 |           "name": "clock",
363 |           "isMut": false,
364 |           "isSigner": false
365 |         }
366 |       ],
367 |       "args": [
368 |         {
369 |           "name": "hvhIdentity",
370 |           "type": "string"
371 |         }
372 |       ]
373 |     },
374 |     {
375 |       "name": "unstakehvh",
376 |       "accounts": [
377 |         {
378 |           "name": "owner",
379 |           "isMut": true,
380 |           "isSigner": true
381 |         },
382 |         {
383 |           "name": "pool",
384 |           "isMut": true,
385 |           "isSigner": false
386 |         },
387 |         {
388 |           "name": "hvhData",
389 |           "isMut": true,
390 |           "isSigner": false
391 |         },
392 |         {
393 |           "name": "stakeState",
394 |           "isMut": true,
395 |           "isSigner": false
396 |         },
397 |         {
398 |           "name": "nftMint",
399 |           "isMut": false,
400 |           "isSigner": false
401 |         },
402 |         {
403 |           "name": "metadata",
404 |           "isMut": true,
405 |           "isSigner": false
406 |         },
407 |         {
408 |           "name": "sourceNftAccount",
409 |           "isMut": true,
410 |           "isSigner": false
411 |         },
412 |         {
413 |           "name": "destNftAccount",
414 |           "isMut": true,
415 |           "isSigner": false
416 |         },
417 |         {
418 |           "name": "tokenProgram",
419 |           "isMut": false,
420 |           "isSigner": false
421 |         },
422 |         {
423 |           "name": "systemProgram",
424 |           "isMut": false,
425 |           "isSigner": false
426 |         },
427 |         {
428 |           "name": "clock",
429 |           "isMut": false,
430 |           "isSigner": false
431 |         }
432 |       ],
433 |       "args": [
434 |         {
435 |           "name": "hvhIdentity",
436 |           "type": "string"
437 |         }
438 |       ]
439 |     },
440 |     {
441 |       "name": "unstakesoldier",
442 |       "accounts": [
443 |         {
444 |           "name": "owner",
445 |           "isMut": true,
446 |           "isSigner": true
447 |         },
448 |         {
449 |           "name": "pool",
450 |           "isMut": true,
451 |           "isSigner": false
452 |         },
453 |         {
454 |           "name": "soldierData",
455 |           "isMut": true,
456 |           "isSigner": false
457 |         },
458 |         {
459 |           "name": "stakeState",
460 |           "isMut": true,
461 |           "isSigner": false
462 |         },
463 |         {
464 |           "name": "nftMint",
465 |           "isMut": false,
466 |           "isSigner": false
467 |         },
468 |         {
469 |           "name": "metadata",
470 |           "isMut": true,
471 |           "isSigner": false
472 |         },
473 |         {
474 |           "name": "sourceNftAccount",
475 |           "isMut": true,
476 |           "isSigner": false
477 |         },
478 |         {
479 |           "name": "destNftAccount",
480 |           "isMut": true,
481 |           "isSigner": false
482 |         },
483 |         {
484 |           "name": "tokenProgram",
485 |           "isMut": false,
486 |           "isSigner": false
487 |         },
488 |         {
489 |           "name": "systemProgram",
490 |           "isMut": false,
491 |           "isSigner": false
492 |         },
493 |         {
494 |           "name": "clock",
495 |           "isMut": false,
496 |           "isSigner": false
497 |         }
498 |       ],
499 |       "args": []
500 |     },
501 |     {
502 |       "name": "claim",
503 |       "accounts": [
504 |         {
505 |           "name": "owner",
506 |           "isMut": true,
507 |           "isSigner": true
508 |         },
509 |         {
510 |           "name": "pool",
511 |           "isMut": true,
512 |           "isSigner": false
513 |         },
514 |         {
515 |           "name": "stakeState",
516 |           "isMut": true,
517 |           "isSigner": false
518 |         },
519 |         {
520 |           "name": "destSoulsAccount",
521 |           "isMut": true,
522 |           "isSigner": false
523 |         },
524 |         {
525 |           "name": "sourceSoulsAccount",
526 |           "isMut": true,
527 |           "isSigner": false
528 |         },
529 |         {
530 |           "name": "burnSoulsAccount",
531 |           "isMut": true,
532 |           "isSigner": false
533 |         },
534 |         {
535 |           "name": "tokenProgram",
536 |           "isMut": false,
537 |           "isSigner": false
538 |         },
539 |         {
540 |           "name": "systemProgram",
541 |           "isMut": false,
542 |           "isSigner": false
543 |         },
544 |         {
545 |           "name": "clock",
546 |           "isMut": false,
547 |           "isSigner": false
548 |         }
549 |       ],
550 |       "args": []
551 |     }
552 |   ],
553 |   "accounts": [
554 |     {
555 |       "name": "Pool",
556 |       "type": {
557 |         "kind": "struct",
558 |         "fields": [
559 |           {
560 |             "name": "owner",
561 |             "type": "publicKey"
562 |           },
563 |           {
564 |             "name": "rand",
565 |             "type": "publicKey"
566 |           },
567 |           {
568 |             "name": "soulsMint",
569 |             "type": "publicKey"
570 |           },
571 |           {
572 |             "name": "totalSouls",
573 |             "type": "u64"
574 |           },
575 |           {
576 |             "name": "stakingPeriod",
577 |             "type": "i64"
578 |           },
579 |           {
580 |             "name": "withdrawPeriod",
581 |             "type": "i64"
582 |           },
583 |           {
584 |             "name": "halosCount",
585 |             "type": "u64"
586 |           },
587 |           {
588 |             "name": "hornsCount",
589 |             "type": "u64"
590 |           },
591 |           {
592 |             "name": "soldierHalosCount",
593 |             "type": "u64"
594 |           },
595 |           {
596 |             "name": "soldierHornsCount",
597 |             "type": "u64"
598 |           },
599 |           {
600 |             "name": "prevWin",
601 |             "type": "u8"
602 |           },
603 |           {
604 |             "name": "winTeamStake",
605 |             "type": "u64"
606 |           },
607 |           {
608 |             "name": "lostTeamStake",
609 |             "type": "u64"
610 |           },
611 |           {
612 |             "name": "soulAmount",
613 |             "type": "u64"
614 |           },
615 |           {
616 |             "name": "hvhPercent",
617 |             "type": "u64"
618 |           },
619 |           {
620 |             "name": "soldierPercent",
621 |             "type": "u64"
622 |           },
623 |           {
624 |             "name": "burnPercent",
625 |             "type": "u64"
626 |           },
627 |           {
628 |             "name": "winPercent",
629 |             "type": "u64"
630 |           },
631 |           {
632 |             "name": "losePercent",
633 |             "type": "u64"
634 |           },
635 |           {
636 |             "name": "startTime",
637 |             "type": "i64"
638 |           },
639 |           {
640 |             "name": "tokenUnit",
641 |             "type": "u64"
642 |           },
643 |           {
644 |             "name": "period",
645 |             "type": "i64"
646 |           },
647 |           {
648 |             "name": "hvhSymbol",
649 |             "type": "string"
650 |           },
651 |           {
652 |             "name": "soldierSymbol",
653 |             "type": "string"
654 |           },
655 |           {
656 |             "name": "tokenHalos",
657 |             "type": "string"
658 |           },
659 |           {
660 |             "name": "tokenHorns",
661 |             "type": "string"
662 |           },
663 |           {
664 |             "name": "burned",
665 |             "type": "bool"
666 |           },
667 |           {
668 |             "name": "bump",
669 |             "type": "u8"
670 |           }
671 |         ]
672 |       }
673 |     },
674 |     {
675 |       "name": "StakeState",
676 |       "type": {
677 |         "kind": "struct",
678 |         "fields": [
679 |           {
680 |             "name": "owner",
681 |             "type": "publicKey"
682 |           },
683 |           {
684 |             "name": "pool",
685 |             "type": "publicKey"
686 |           },
687 |           {
688 |             "name": "halosCount",
689 |             "type": "u64"
690 |           },
691 |           {
692 |             "name": "hornsCount",
693 |             "type": "u64"
694 |           },
695 |           {
696 |             "name": "soldierHalosCount",
697 |             "type": "u64"
698 |           },
699 |           {
700 |             "name": "soldierHornsCount",
701 |             "type": "u64"
702 |           },
703 |           {
704 |             "name": "lastStakeTime",
705 |             "type": "i64"
706 |           },
707 |           {
708 |             "name": "claimed",
709 |             "type": "bool"
710 |           },
711 |           {
712 |             "name": "bump",
713 |             "type": "u8"
714 |           }
715 |         ]
716 |       }
717 |     },
718 |     {
719 |       "name": "HvHData",
720 |       "type": {
721 |         "kind": "struct",
722 |         "fields": [
723 |           {
724 |             "name": "owner",
725 |             "type": "publicKey"
726 |           },
727 |           {
728 |             "name": "pool",
729 |             "type": "publicKey"
730 |           },
731 |           {
732 |             "name": "nftMint",
733 |             "type": "publicKey"
734 |           },
735 |           {
736 |             "name": "nftAccount",
737 |             "type": "publicKey"
738 |           },
739 |           {
740 |             "name": "stakeTime",
741 |             "type": "i64"
742 |           },
743 |           {
744 |             "name": "unstaked",
745 |             "type": "bool"
746 |           }
747 |         ]
748 |       }
749 |     },
750 |     {
751 |       "name": "SoldierData",
752 |       "type": {
753 |         "kind": "struct",
754 |         "fields": [
755 |           {
756 |             "name": "owner",
757 |             "type": "publicKey"
758 |           },
759 |           {
760 |             "name": "pool",
761 |             "type": "publicKey"
762 |           },
763 |           {
764 |             "name": "nftMint",
765 |             "type": "publicKey"
766 |           },
767 |           {
768 |             "name": "nftAccount",
769 |             "type": "publicKey"
770 |           },
771 |           {
772 |             "name": "stakeTime",
773 |             "type": "i64"
774 |           },
775 |           {
776 |             "name": "hvhStr",
777 |             "type": "string"
778 |           },
779 |           {
780 |             "name": "unstaked",
781 |             "type": "bool"
782 |           }
783 |         ]
784 |       }
785 |     }
786 |   ],
787 |   "errors": [
788 |     {
789 |       "code": 6000,
790 |       "name": "TokenMintToFailed",
791 |       "msg": "Token mint to failed"
792 |     },
793 |     {
794 |       "code": 6001,
795 |       "name": "TokenSetAuthorityFailed",
796 |       "msg": "Token authority failed"
797 |     },
798 |     {
799 |       "code": 6002,
800 |       "name": "TokenTransferFailed",
801 |       "msg": "Token transfer failed"
802 |     },
803 |     {
804 |       "code": 6003,
805 |       "name": "InvalidTokenAccount",
806 |       "msg": "Invalid token account"
807 |     },
808 |     {
809 |       "code": 6004,
810 |       "name": "InvalidTokenMint",
811 |       "msg": "Invalid token mint"
812 |     },
813 |     {
814 |       "code": 6005,
815 |       "name": "InvalidMetadata",
816 |       "msg": "Invalid metadata"
817 |     },
818 |     {
819 |       "code": 6006,
820 |       "name": "InvalidHvHData",
821 |       "msg": "Invalid HvHData account"
822 |     },
823 |     {
824 |       "code": 6007,
825 |       "name": "InvalidStakeState",
826 |       "msg": "Invalid stakestate account"
827 |     },
828 |     {
829 |       "code": 6008,
830 |       "name": "InvalidTime",
831 |       "msg": "Invalid time"
832 |     },
833 |     {
834 |       "code": 6009,
835 |       "name": "InvalidStakingPeriod",
836 |       "msg": "Invalid Staking Period"
837 |     },
838 |     {
839 |       "code": 6010,
840 |       "name": "InvalidWithdrawPeriod",
841 |       "msg": "Invalid Withdraw Period"
842 |     },
843 |     {
844 |       "code": 6011,
845 |       "name": "PassedStakingPeriod",
846 |       "msg": "Passed Staking Period"
847 |     },
848 |     {
849 |       "code": 6012,
850 |       "name": "WithdrawFirst",
851 |       "msg": "Please withdraw first"
852 |     },
853 |     {
854 |       "code": 6013,
855 |       "name": "PassedWithdrawPeriod",
856 |       "msg": "Passed Withdraw Period"
857 |     },
858 |     {
859 |       "code": 6014,
860 |       "name": "InvalidUnstakeTime",
861 |       "msg": "Invalid Unstake Time"
862 |     },
863 |     {
864 |       "code": 6015,
865 |       "name": "AlreadyUnstaked",
866 |       "msg": "Already unstaked"
867 |     },
868 |     {
869 |       "code": 6016,
870 |       "name": "AlreadyClaimed",
871 |       "msg": "Already claimed"
872 |     },
873 |     {
874 |       "code": 6017,
875 |       "name": "InvalidBurnAccount",
876 |       "msg": "Invalid Burn Account"
877 |     }
878 |   ]
879 | }


--------------------------------------------------------------------------------
/src/pages/stake.tsx:
--------------------------------------------------------------------------------
   1 | import { Fragment, useRef, useState, useEffect } from 'react';
   2 | import { Button, Modal } from 'react-bootstrap';
   3 | import useNotify from './notify'
   4 | import { useWallet, useConnection } from "@solana/wallet-adapter-react";
   5 | import * as anchor from "@project-serum/anchor";
   6 | import {AccountLayout,MintLayout,TOKEN_PROGRAM_ID,Token,ASSOCIATED_TOKEN_PROGRAM_ID} from "@solana/spl-token";
   7 | import { TokenListProvider, TokenInfo } from '@solana/spl-token-registry';
   8 | import { programs } from '@metaplex/js'
   9 | import moment from 'moment';
  10 | import Loading from "./Loading";
  11 | // import win_horns from "./video/win_horns.mov";
  12 | // import winhorns from "../asset/video/winhorns.mp4";
  13 | import winhorns from "../asset/video/winhorns.mp4";
  14 | import winhalos from "../asset/video/winhalos.mp4";
  15 | import { FaDiscord } from "react-icons/fa";
  16 | import { FaTwitter } from "react-icons/fa";
  17 | // import drawn from "../asset/video/drawn.mp4";
  18 | import {
  19 |   Connection,
  20 |   Keypair,
  21 |   Signer,
  22 |   PublicKey,
  23 |   Transaction,
  24 |   TransactionInstruction,
  25 |   TransactionSignature,
  26 |   ConfirmOptions,
  27 |   sendAndConfirmRawTransaction,
  28 |   RpcResponseAndContext,
  29 |   SimulatedTransactionResponse,
  30 |   Commitment,
  31 |   LAMPORTS_PER_SOL,
  32 |   SYSVAR_RENT_PUBKEY,
  33 |   SYSVAR_CLOCK_PUBKEY,
  34 |   clusterApiUrl,
  35 |   StakeInstruction
  36 | } from "@solana/web3.js";
  37 | import axios from "axios"
  38 | import { token } from '@project-serum/anchor/dist/cjs/utils';
  39 | import { createJsxClosingElement, moveEmitHelpers, PollingWatchKind } from 'typescript';
  40 | import { clearInterval } from 'timers';
  41 | import { unstable_renderSubtreeIntoContainer } from 'react-dom';
  42 | import SelectInput from '@mui/material/Select/SelectInput';
  43 | 
  44 | let wallet : any
  45 | // let conn = new Connection(clusterApiUrl('mainnet-beta'))
  46 | let conn = new Connection("https://ssc-dao.genesysgo.net/");
  47 | let notify : any
  48 | const { metadata: { Metadata } } = programs
  49 | const COLLECTION_NAME = "Gorilla"
  50 | const TOKEN_METADATA_PROGRAM_ID = new anchor.web3.PublicKey(
  51 |   "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
  52 | )
  53 | const programId = new PublicKey('BYXYF76vQSBiiMGpkmBLtiUWsa5TDLQBPueFuPzPrj9E')
  54 | const idl = require('./solana_anchor.json')
  55 | const confirmOption : ConfirmOptions = {
  56 |     commitment : 'finalized',
  57 |     preflightCommitment : 'finalized',
  58 |     skipPreflight : false
  59 | }
  60 | 
  61 | // const REWARD_TOKEN = 'sou1ELxm3XpLWpnjP81KaoigPPCwbNUFAZ4dhqifq13' //Mainnet beta
  62 | const REWARD_TOKEN = 'sou1ELxm3XpLWpnjP81KaoigPPCwbNUFAZ4dhqifq13'
  63 | 
  64 | let POOL = new PublicKey('Dw14gB5BKLzy3SqkQRDjkKFcqrDtMgL9sUdZFXfG4aAq') // Devnet
  65 | // const HVH_DATA_SIZE = 8 + 32 + 32 + 32 + 32 + 8 + 1;
  66 | const HVH_DATA_SIZE = 32 * 4 + 8 + 1;
  67 | const SOLDIER_DATA_SIZE = 32 * 4 + 8 + 1 +  4 + 10;
  68 | 
  69 | const DEVNET_ID = 103;
  70 | 
  71 | let init = true;
  72 | let ownerstakedinfo: any = null;
  73 | let pD : any ;
  74 | // let claimAmount = 0
  75 | let nfts : any[] = []
  76 | let soldiers : any[] = []
  77 | let stakedNfts : any[] = []
  78 | let stakedSoldiers : any[] = []
  79 | let catchFlag : boolean = false;
  80 | let selected_soldier : any = {};
  81 | const delay_ms : Number = 30;
  82 | let stakeallflag : Boolean = true;
  83 | const axios_timeout : any = 2000;
  84 | 
  85 | const getTimeZoneOffset = (date : any, timeZone : any) => {
  86 | 
  87 |   // Abuse the Intl API to get a local ISO 8601 string for a given time zone.
  88 |   const options = {
  89 |       timeZone, calendar: 'iso8601', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false,
  90 | };
  91 |  // @ts-ignore
  92 |  const dateTimeFormat = new Intl.DateTimeFormat(undefined, options);
  93 |  const parts = dateTimeFormat.formatToParts(date);
  94 |  const map = new Map(parts.map((x) => [x.type, x.value]));
  95 |  const year = map.get('year');
  96 |  const month = map.get('month');
  97 |  const day = map.get('day');
  98 |  const hour = map.get('hour');
  99 |  const minute = map.get('minute');
 100 |  const second = map.get('second');
 101 |  const ms = date.getMilliseconds().toString().padStart(3, '0');
 102 |  const iso = `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}`;
 103 | 
 104 |  // Lie to the Date object constructor that it's a UTC time.
 105 |  const lie = new Date(`${iso}Z`);
 106 | 
 107 |  // Return the difference in timestamps, as minutes
 108 |  // Positive values are West of GMT, opposite of ISO 8601
 109 |  // this matches the output of `Date.getTimeZoneOffset`
 110 |  // @ts-ignore
 111 |  return -(lie - date) / 60 / 1000;
 112 | };
 113 | 
 114 | function sleep(time: any){
 115 |   return new Promise((resolve)=>setTimeout(resolve,time)
 116 | )
 117 | }
 118 | 
 119 | const getTimeStampOfDateInEnvTimeZone = (timeStamp:number, userTimezone: string, timezoneForTesting:string) => {
 120 | 
 121 |   const envTimeZoneOffsetInMinutes = getTimeZoneOffset(new Date(timeStamp), timezoneForTesting);
 122 |   const userTimeZoneOffsetInMInutes = getTimeZoneOffset(new Date(timeStamp), userTimezone);
 123 |   const difference = userTimeZoneOffsetInMInutes - envTimeZoneOffsetInMinutes;
 124 |   const diffInMilliseconds = difference * 60000;
 125 |   return timeStamp - diffInMilliseconds;
 126 | };
 127 | 
 128 | const createAssociatedTokenAccountInstruction = (
 129 |   associatedTokenAddress: anchor.web3.PublicKey,
 130 |   payer: anchor.web3.PublicKey,
 131 |   walletAddress: anchor.web3.PublicKey,
 132 |   splTokenMintAddress: anchor.web3.PublicKey
 133 |     ) => {  
 134 |   const keys = [
 135 |     { pubkey: payer, isSigner: true, isWritable: true },
 136 |     { pubkey: associatedTokenAddress, isSigner: false, isWritable: true },
 137 |     { pubkey: walletAddress, isSigner: false, isWritable: false },
 138 |     { pubkey: splTokenMintAddress, isSigner: false, isWritable: false },
 139 |     {
 140 |       pubkey: anchor.web3.SystemProgram.programId,
 141 |       isSigner: false,
 142 |       isWritable: false,
 143 |     },
 144 |     { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
 145 |     {
 146 |       pubkey: anchor.web3.SYSVAR_RENT_PUBKEY,
 147 |       isSigner: false,
 148 |       isWritable: false,
 149 |     },
 150 |   ];
 151 |   return new anchor.web3.TransactionInstruction({
 152 |     keys,
 153 |     programId: ASSOCIATED_TOKEN_PROGRAM_ID,
 154 |     data: Buffer.from([]),
 155 |   });
 156 | }
 157 | 
 158 | const getTokenListInfo = async (address:String, chainId:Number) => {
 159 |   const tokens: any = await new TokenListProvider().resolve();
 160 |   const tokenlist: any = await tokens.filterByChainId(chainId).getList();
 161 |   let tokenitem;
 162 |   await tokenlist.map((item: any) => {
 163 |     if(item.address === address) {
 164 |       tokenitem = item;
 165 |     }
 166 |   });
 167 |   return tokenitem;
 168 | }
 169 | 
 170 | const getMasterEdition = async (
 171 |   mint: anchor.web3.PublicKey
 172 |     ): Promise<anchor.web3.PublicKey> => {
 173 |   return (
 174 |     await anchor.web3.PublicKey.findProgramAddress(
 175 |       [
 176 |         Buffer.from("metadata"),
 177 |         TOKEN_METADATA_PROGRAM_ID.toBuffer(),
 178 |         mint.toBuffer(),
 179 |         Buffer.from("edition"),
 180 |       ],
 181 |       TOKEN_METADATA_PROGRAM_ID
 182 |     )
 183 |   )[0];
 184 | };
 185 | 
 186 | const getMetadata = async (
 187 |   mint: anchor.web3.PublicKey
 188 |     ): Promise<anchor.web3.PublicKey> => {
 189 |   return (
 190 |     await anchor.web3.PublicKey.findProgramAddress(
 191 |       [
 192 |         Buffer.from("metadata"),
 193 |         TOKEN_METADATA_PROGRAM_ID.toBuffer(),
 194 |         mint.toBuffer(),
 195 |       ],
 196 |       TOKEN_METADATA_PROGRAM_ID
 197 |     )
 198 |   )[0];
 199 | };
 200 | 
 201 | const getTokenWallet = async (
 202 |   wallet: anchor.web3.PublicKey,
 203 |   mint: anchor.web3.PublicKey
 204 |     ) => {
 205 |   return (
 206 |     await anchor.web3.PublicKey.findProgramAddress(
 207 |       [wallet.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()],
 208 |       ASSOCIATED_TOKEN_PROGRAM_ID
 209 |     )
 210 |   )[0];
 211 | };
 212 | 
 213 | const getStakeStateInfo = async (address: PublicKey) => {
 214 |   let wallet = new anchor.Wallet(Keypair.generate())
 215 |   let provider = new anchor.Provider(conn,wallet,confirmOption)
 216 |   const program = new anchor.Program(idl,programId,provider)
 217 |   let poolData = await program.account.stakeState.fetch(address)
 218 |   return poolData;
 219 | }
 220 | 
 221 | const getStakeDataInfo = async (address: PublicKey) => {
 222 |   let wallet = new anchor.Wallet(Keypair.generate())
 223 |   let provider = new anchor.Provider(conn,wallet,confirmOption)
 224 |   const program = new anchor.Program(idl,programId,provider)
 225 |   let poolData = await program.account.hvHData.fetch(address)
 226 |   return poolData;
 227 | }
 228 | 
 229 | const getSoldierDataInfo = async (address: PublicKey) => {
 230 |   let wallet = new anchor.Wallet(Keypair.generate())
 231 |   let provider = new anchor.Provider(conn,wallet,confirmOption)
 232 |   const program = new anchor.Program(idl,programId,provider)
 233 |   let poolData = await program.account.soldierData.fetch(address)
 234 |   return poolData;
 235 | }
 236 | 
 237 | async function getTokenAccountBalance(owner: PublicKey, mint: PublicKey) {
 238 |   let amount = 0
 239 |     if( owner != null ){
 240 |       const tokenAccount = await getTokenWallet(owner, mint)
 241 |       if(await conn.getAccountInfo(tokenAccount)){
 242 |         let resp : any = (await conn.getTokenAccountBalance(tokenAccount)).value
 243 |         amount = Number(resp.uiAmount)
 244 |       }
 245 |     }
 246 |   return amount;
 247 | }
 248 | 
 249 | async function getProgramAccount(owner : PublicKey, pool: PublicKey, token: PublicKey) {
 250 |   // console.log(owner, pool, token);
 251 |   return await PublicKey.findProgramAddress([owner.toBuffer(),pool.toBuffer(), token.toBuffer()], programId)
 252 | }
 253 | 
 254 | async function getOwnerStakeStateInfo() {
 255 |   const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 256 |   let [stakeState] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
 257 |   if((await conn.getAccountInfo(stakeState)) == null) {
 258 |     return;
 259 |   }
 260 | 
 261 |   let balance = await getTokenAccountBalance(wallet.publicKey, reward_mint);
 262 | 
 263 |   let stateinfo = await getStakeStateInfo(stakeState);
 264 |   //halosCount hornsCount soldierHalosCount soldierHornsCount
 265 |   // console.log("state data", stateinfo)
 266 |   let halos_mul = stateinfo.halosCount.toNumber() / 10 | 0;
 267 |   let horns_mul = stateinfo.hornsCount.toNumber() / 10 | 0;
 268 | 
 269 |   let halos_unit = stateinfo.halosCount.toNumber() + (halos_mul + 1) * stateinfo.soldierHalosCount.toNumber();
 270 |   let horns_unit = stateinfo.hornsCount.toNumber() + (horns_mul + 1) * stateinfo.soldierHornsCount.toNumber();
 271 | 
 272 |   ownerstakedinfo = {
 273 |     ...stateinfo,
 274 |     souls : balance,
 275 |     halos_unit : halos_unit,
 276 |     horns_unit : horns_unit
 277 |   }
 278 | }
 279 | 
 280 | let init_flag= false;
 281 | 
 282 | export function SelectHHModal(props : any) {
 283 | 
 284 |   return (
 285 |     <Modal
 286 |       show = {props.show}
 287 |       onHide = {props.onHide}
 288 |       size="sm"
 289 |       aria-labelledby="contained-modal-title-vcenter"
 290 |       centered
 291 |     >
 292 |       <Modal.Header closeButton>
 293 |         <Modal.Title id="contained-modal-title-vcenter">
 294 |           Select Team
 295 |         </Modal.Title>
 296 |       </Modal.Header>
 297 |       <Modal.Body>
 298 |         {pD && <h5>
 299 |           {pD.win_team_stake} to Won team and {pD.lost_team_stake} to Lost team
 300 |         </h5>}
 301 |       </Modal.Body>
 302 |       <Modal.Footer>
 303 |         <Button onClick={props.OnHalos}>Halos</Button>
 304 |         <Button onClick={props.OnHorns}>Horns</Button>
 305 |       </Modal.Footer>
 306 |     </Modal>
 307 |   );
 308 | }
 309 | 
 310 | export default function Stake(){
 311 | 
 312 | 	const [changed, setChange] = useState(true)
 313 | 	const [rewardAmount, setRewardAmount] = useState(10)
 314 | 	const [period, setPeriod] = useState(60)
 315 | 	const [withdrawable, setWithdrawable] = useState(7)
 316 | 	const [collectionName, setCollectionName] = useState(COLLECTION_NAME)
 317 | 	const [rewardToken, setRewardToken] = useState(REWARD_TOKEN)
 318 |   const [todaystr, setDateTime] = useState(""); // Save the current date to be able to trigger an update
 319 |   const [loading, setLoading] = useState(false);
 320 |   const [claimableAmount, setClaimAmount] = useState(0);
 321 |   const [stakingPeriod, setStakingPeriod] = useState({start:"", end:""});
 322 |   const [withdrawPeriod, setWithdrawPeriod] = useState({start:"", end: ""});
 323 |   const [fightingFlag, setFightingFlag] = useState(0);//default halos win
 324 |   const [winTeam, setWinTeam] = useState("");
 325 |   const [modalShow, setModalShow] = useState(false);
 326 |   // const [stakeallflag, setStakeAllFlag] = useState(true);
 327 |   // const [init, setInitFlag] = useState(false);
 328 |   
 329 |   let stakedinfo;
 330 | 
 331 |   wallet = useWallet()
 332 | 	notify = useNotify()
 333 | 
 334 |   useEffect(() => {
 335 |     const timer = setInterval(() => {
 336 |       getTime();
 337 |     },1000);
 338 | 
 339 |     return () => {
 340 |       clearInterval(timer);
 341 |     }
 342 |   }, []);
 343 | 
 344 |   useEffect(() => {
 345 |     if(wallet){
 346 |       if(!wallet.disconnecting && wallet.publicKey && !init_flag) {
 347 |         init_flag = true;
 348 |         console.log("get info")
 349 |         getNfts()
 350 |       }
 351 |     }
 352 |   }, [wallet])
 353 |   // useEffect(() => {
 354 |   //   if(wallet.publicKey !== undefined) {
 355 |   //     console.log("wallet", wallet)
 356 |   //     getNfts()
 357 |   //     init = false
 358 |   //   }
 359 |   // }, [loading])
 360 | 
 361 |   // const testTimezone = () => {
 362 | 
 363 |   //   const timezoneOffset = (new Date()).getTimezoneOffset();
 364 | 
 365 |   //   console.log("timezone offset", timezoneOffset);
 366 | 
 367 |   //   const date = new Date();
 368 |   //   const dateAsString = date.toString();
 369 |   //   console.log("date string", dateAsString)
 370 | 
 371 |   //   console.log(moment().utcOffset()); // (-240, -120, -60, 0, 60, 120, 240, etc.)
 372 |   //   // const timezone = dateAsString.match(/\(([^\)]+)\)$/)[1];
 373 | 
 374 |   //   // console.log(timezone);
 375 | 
 376 |   // }
 377 | 
 378 |   const setSelectSoldier = (nftaccount : any, nftmint : any) => {
 379 |     selected_soldier = {nftaccount, nftmint}
 380 |     stakeallflag = true;
 381 |     setModalShow(true)
 382 |   }
 383 | 
 384 |   const setSelectAllFlag = () => {
 385 |     stakeallflag = false;
 386 |     setModalShow(true);
 387 |   }
 388 | 
 389 |   const stakeSoldierToHalos = () => {
 390 |     if(stakeallflag)
 391 |       stakeSoldier(selected_soldier.nftaccount, selected_soldier.nftmint, pD.token_halos)
 392 |     else
 393 |       stakeSoldiersAll(pD.token_halos)
 394 |     setModalShow(false)
 395 |   }
 396 | 
 397 |   const stakeSoldierToHorns = () => {
 398 |     if(stakeallflag)
 399 |       stakeSoldier(selected_soldier.nftaccount, selected_soldier.nftmint, pD.token_horns)
 400 |     else 
 401 |       stakeSoldiersAll(pD.token_horns)
 402 |     setModalShow(false)
 403 |   }
 404 | 
 405 |   const getTime = () => {
 406 |     // testTimezone();
 407 |     const today = new Date();
 408 |     setDateTime(today.toLocaleString("en-US"));
 409 | 
 410 |     if(pD) {
 411 |       catchClaimPeriod();
 412 |     }
 413 | 
 414 |     if(pD) {
 415 |       if(moment().unix() > Date.parse(pD.end_withdraw) / 1000) {
 416 |         updateStakingPeriod();
 417 |       }
 418 |     }
 419 |   }
 420 | 
 421 |   const updateStakingPeriod = async () => {
 422 | 
 423 |     let time_period = getStakingPeriod();
 424 | 
 425 |     const time_interval = moment().unix() - time_period.withdraw_limit;
 426 | 
 427 |     let day_interval = time_interval / (time_period.total_period * pD.period);
 428 |     day_interval = day_interval | 0;
 429 | 
 430 |     if(time_interval < 0)
 431 |       day_interval--;
 432 | 
 433 |     const starttime = Date.parse(pD.abs_start_time) / 1000 + pD.period * (day_interval + 1) * time_period.total_period;
 434 |     const next_staking_limit = starttime + pD.period * pD.staking_period;
 435 |     const withdrawtime = next_staking_limit + 1;
 436 |     const next_withdraw_limit = withdrawtime + pD.period * pD.withdraw_period;
 437 | 
 438 |     const next_staking_start = new Date(starttime * 1000);
 439 |     const next_staking_end = new Date(next_staking_limit * 1000);
 440 |     const next_withdraw_start = new Date(withdrawtime * 1000);
 441 |     const next_withdraw_end = new Date(next_withdraw_limit * 1000);
 442 | 
 443 |     pD.start_time = next_staking_start;
 444 |     pD.end_time = next_staking_end;
 445 | 
 446 |     pD.start_withdraw = next_withdraw_start;
 447 |     pD.end_withdraw = next_withdraw_end;
 448 | 
 449 |     setStakingPeriod({
 450 |       start: next_staking_start.toLocaleString("en-US"),
 451 |       end: next_staking_end.toLocaleString("en-US"),
 452 |     })
 453 | 
 454 |     setWithdrawPeriod({
 455 |       start: next_withdraw_start.toLocaleString("en-US"),
 456 |       end: next_withdraw_end.toLocaleString("en-US")
 457 |     })
 458 |   }
 459 | 
 460 |   const catchClaimPeriod = async () => {
 461 | 
 462 |     if((moment().unix() > (Date.parse(pD.end_time) / 1000)) && (moment().unix() < (Date.parse(pD.end_withdraw) / 1000))) {
 463 |       if(catchFlag)
 464 |         return;
 465 |       getClaimAmount(conn, wallet.publicKey);
 466 | 
 467 |       let halos_mul = pD.halos_count / 10 | 0;
 468 |       let horns_mul = pD.horns_count / 10 | 0;
 469 | 
 470 |       let total_halos_soldiers = pD.halos_count + (halos_mul + 1) * pD.soldier_halos_count;
 471 |       let total_horns_soldiers = pD.horns_count + pD.soldier_horns_count * (horns_mul + 1);
 472 | 
 473 |       // console.log("test val", total_halos_soldiers, total_horns_soldiers)
 474 | 
 475 |       if(total_halos_soldiers > total_horns_soldiers) {
 476 |         setFightingFlag(0);// halos win
 477 |         setWinTeam("Halos");
 478 |       } else if(total_halos_soldiers < total_horns_soldiers) {
 479 |         setFightingFlag(1);// horns win
 480 |         setWinTeam("Horns");
 481 |       } else {
 482 |         setFightingFlag(2);// drawn
 483 |         setWinTeam("Drawn");
 484 |       }
 485 | 
 486 |       catchFlag = true;
 487 |     } else {
 488 |       catchFlag = false;
 489 |     }
 490 |   }
 491 | 
 492 |   async function validateStaking(
 493 |     conn : Connection,
 494 |     owner : PublicKey
 495 |     ){
 496 |     console.log("+ validate Staking")
 497 | 
 498 |     if(!wallet.connected) {
 499 |       notify('error', 'Wallet is unconnected!');
 500 |       // setLoading(false);
 501 |       return false;
 502 |     }
 503 | 
 504 |     const provider = new anchor.Provider(conn, wallet, anchor.Provider.defaultOptions());
 505 |     const program = new anchor.Program(idl, programId, provider);
 506 | 
 507 |     await getPoolData();
 508 | 
 509 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 510 | 
 511 |     let [stakeState] = await getProgramAccount(owner, POOL, reward_mint);
 512 | 
 513 |     let balance = await getTokenAccountBalance(owner, reward_mint);
 514 | 
 515 |     if(balance < pD.soulAmount) {
 516 |       notify('error', 'Insufficient tokens!');
 517 |       // setLoading(false);
 518 |       return false;
 519 |     }
 520 | 
 521 |     // console.log(time_period.staking_limit, moment().unix(), time_period.withdraw_limit);
 522 |     
 523 |     if(moment().unix() >= Date.parse(pD.end_time) / 1000 && moment().unix() <= Date.parse(pD.end_withdraw) / 1000) {
 524 |       notify('error', 'Staking period has passed!');
 525 |       // setLoading(false)
 526 |       return false;
 527 |     }
 528 | 
 529 |     if((await conn.getAccountInfo(stakeState)) != null) {
 530 |       stakedinfo = await getStakeStateInfo(stakeState)
 531 |       // console.log(moment().unix(), time_period.staking_limit)
 532 |       if(moment().unix() < Date.parse(pD.end_time) / 1000) {
 533 |         if(stakedinfo.lastStakeTime.toNumber() !== 0 && stakedinfo.lastStakeTime.toNumber() < (Date.parse(pD.start_time) / 1000)) {
 534 |             if(stakedinfo.halosCount.toNumber() != 0 || stakedinfo.hornsCount.toNumber() != 0 || stakedinfo.soldierHalosCount.toNumber() != 0 || stakedinfo.soldierHornsCount.toNumber() != 0) {
 535 |               // console.log("test")
 536 |               notify('error', 'You should claim and unstake nft tokens before stake!');
 537 |               // setLoading(false)
 538 |               return false;
 539 |             }
 540 |         }
 541 |       }
 542 |     }
 543 |       
 544 |     // console.log(starttime, moment().unix(), next_staking_limit)
 545 |     if(moment().unix() > Date.parse(pD.end_withdraw) / 1000) {
 546 |       // console.log("test")
 547 |       notify('error', 'Staking period has passed!');
 548 |       // setLoading(false);
 549 |       return false;
 550 |     }
 551 | 
 552 |     return true;
 553 |   }
 554 | 
 555 |   async function stake(
 556 |     nftAccount : PublicKey,
 557 |     nftMint : PublicKey,
 558 |     hvhtype : String
 559 |     ){
 560 | 
 561 |     setLoading(true);
 562 | 
 563 |     if(!await validateStaking(conn, wallet.publicKey)) {
 564 |       setLoading(false);
 565 |       return;
 566 |     }
 567 | 
 568 |     console.log("+ stake")
 569 | 
 570 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
 571 |     let program = new anchor.Program(idl,programId,provider)
 572 | 
 573 |     // const stakeData = Keypair.generate()
 574 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 575 |     const metadata = await getMetadata(nftMint)
 576 |     const sourceNftAccount = nftAccount;
 577 |     const destNftAccount = await getTokenWallet(POOL,nftMint)
 578 |     const srcSoulsAccount = await getTokenWallet(wallet.publicKey, reward_mint);
 579 |     const destSoulsAccount = await getTokenWallet(POOL, reward_mint);
 580 | 
 581 |     const accountInfo: any = await conn.getParsedAccountInfo(metadata);
 582 |     let metadata1 : any = new Metadata(wallet.publicKey.toString(), accountInfo.value);
 583 | 
 584 |     let [stakeState, bump] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
 585 |     let [hvh_data, bump1] = await getProgramAccount(wallet.publicKey, POOL, nftMint);
 586 | 
 587 |     let transaction = new Transaction()
 588 |     // signers.push(stakeState)
 589 |     if((await conn.getAccountInfo(destNftAccount)) == null)
 590 |       transaction.add(createAssociatedTokenAccountInstruction(destNftAccount,wallet.publicKey,POOL,nftMint))
 591 |     if((await conn.getAccountInfo(destSoulsAccount)) == null)
 592 |       transaction.add(createAssociatedTokenAccountInstruction(destSoulsAccount,wallet.publicKey,POOL,reward_mint))
 593 |     if((await conn.getAccountInfo(hvh_data)) == null) {
 594 |       transaction.add(
 595 |         await program.instruction.initHvhData(new anchor.BN(bump1),
 596 |         {
 597 |           accounts: {
 598 |             owner : wallet.publicKey,
 599 |             pool : POOL,
 600 |             nftMint: nftMint,
 601 |             hvhData: hvh_data,
 602 |             systemProgram : anchor.web3.SystemProgram.programId
 603 |           }
 604 |         })
 605 |       )
 606 |     }
 607 | 
 608 |     if((await conn.getAccountInfo(stakeState)) == null) {
 609 |       transaction.add(
 610 |         await program.instruction.initStakeState(new anchor.BN(bump),
 611 |         {
 612 |           accounts: {
 613 |             owner : wallet.publicKey,
 614 |             pool : POOL,
 615 |             soulsMint: reward_mint,
 616 |             stakeState: stakeState,
 617 |             systemProgram : anchor.web3.SystemProgram.programId
 618 |           }
 619 |         })
 620 |       )
 621 |     }
 622 | 
 623 |     let signers : Keypair[] = []
 624 |     // signers.push(stakeData)
 625 |     transaction.add(
 626 |       await program.instruction.stakehvh(hvhtype, {
 627 |         accounts: {
 628 |           owner : wallet.publicKey,
 629 |           pool : POOL,
 630 |           hvhData : hvh_data,
 631 |           stakeState : stakeState,
 632 |           nftMint : nftMint,
 633 |           metadata : metadata,
 634 |           sourceNftAccount : sourceNftAccount,
 635 |           destNftAccount : destNftAccount,
 636 |           sourceSoulsAccount:srcSoulsAccount,
 637 |           destSoulsAccount:destSoulsAccount,
 638 |           tokenProgram : TOKEN_PROGRAM_ID,
 639 |           systemProgram : anchor.web3.SystemProgram.programId,
 640 |           clock : SYSVAR_CLOCK_PUBKEY
 641 |         }
 642 |       })
 643 |     )
 644 | 
 645 |     await sendTransaction(transaction,signers)
 646 | 
 647 |     setLoading(false);
 648 |     await getNfts();
 649 | 
 650 |   }
 651 | 
 652 |   async function stakeAll(hvflag : boolean){
 653 | 
 654 |     setLoading(true);
 655 | 
 656 |     if(nfts.length <= 0) {
 657 |       setLoading(false);
 658 |       return;
 659 |     }
 660 | 
 661 |     console.log("+ stakeAll")
 662 | 
 663 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
 664 |     let program = new anchor.Program(idl,programId,provider)
 665 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 666 |     let [stakeState, bump] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
 667 | 
 668 |     let stakeData = null;
 669 |     let metadata = null;
 670 |     let sourceNftAccount = null;
 671 |     let destNftAccount = null;
 672 |     let srcSoulsAccount = null;
 673 |     let destSoulsAccount = null;
 674 | 
 675 |     let accountInfo: any = null;
 676 |     let metadata1 : any = null;
 677 |     // nft.account_address, nft.mint_address, nft.attributes[0].value
 678 | 
 679 |     // let instructions : TransactionInstruction[] = []
 680 | 
 681 |     let transactiona = new Transaction()
 682 |     
 683 |     if((await conn.getAccountInfo(stakeState)) == null) {
 684 |       transactiona.add(
 685 |         await program.instruction.initStakeState(new anchor.BN(bump),
 686 |         {
 687 |           accounts: {
 688 |             owner : wallet.publicKey,
 689 |             pool : POOL,
 690 |             soulsMint: reward_mint,
 691 |             stakeState: stakeState,
 692 |             systemProgram : anchor.web3.SystemProgram.programId
 693 |           }
 694 |         })
 695 |         )
 696 |         await sendTransaction(transactiona, [])
 697 |     }
 698 |       
 699 |     let instructions : TransactionInstruction[] = []
 700 |     // let transaction = new Transaction()
 701 |     // let signers : Keypair[] = []
 702 |     let j = 0;
 703 | 
 704 |     if(!await validateStaking(conn, wallet.publicKey)) {
 705 |       // await getNfts();
 706 |       setLoading(false);
 707 |       return;
 708 |     }
 709 | 
 710 |     let i = 0;
 711 |     
 712 |     for(let i = 0; i < nfts.length; i++) {
 713 | 
 714 |       if(hvflag && nfts[i].attributes[0].value != pD.token_halos) {
 715 |         // console.log("halos", nfts[i].attributes[0].value, pD.token_halos)
 716 |         continue;
 717 |       }
 718 | 
 719 |       if(!hvflag && nfts[i].attributes[0].value != pD.token_horns) {
 720 |         // console.log("horns", nfts[i].attributes[0].value, pD.token_horns)
 721 |         continue;
 722 |       }
 723 | 
 724 |       metadata = await getMetadata(nfts[i].mint_address)  
 725 |       sourceNftAccount = nfts[i].account_address   
 726 |       destNftAccount = await getTokenWallet(POOL, nfts[i].mint_address) 
 727 |       srcSoulsAccount = await getTokenWallet(wallet.publicKey, reward_mint)  
 728 |       destSoulsAccount = await getTokenWallet(POOL, reward_mint);
 729 |       
 730 |       accountInfo = await conn.getParsedAccountInfo(metadata);
 731 |       metadata1 = new Metadata(wallet.publicKey.toString(), accountInfo.value);
 732 |  
 733 |       let [hvh_data, bump1] = await getProgramAccount(wallet.publicKey, POOL, nfts[i].mint_address);
 734 | 
 735 |       if((await conn.getAccountInfo(hvh_data)) == null) {
 736 |         instructions.push(
 737 |           await program.instruction.initHvhData(new anchor.BN(bump1),
 738 |           {
 739 |             accounts: {
 740 |               owner : wallet.publicKey,
 741 |               pool : POOL,
 742 |               nftMint: nfts[i].mint_address,
 743 |               hvhData: hvh_data,
 744 |               systemProgram : anchor.web3.SystemProgram.programId
 745 |             }
 746 |           })
 747 |         )
 748 |         j++;
 749 |       }
 750 | 
 751 | 
 752 |       if((await conn.getAccountInfo(destNftAccount)) == null) {
 753 |         instructions.push(createAssociatedTokenAccountInstruction(destNftAccount,wallet.publicKey,POOL, nfts[i].mint_address))
 754 |         j++;
 755 |       }
 756 |       if((await conn.getAccountInfo(destSoulsAccount)) == null) {
 757 |         instructions.push(createAssociatedTokenAccountInstruction(destSoulsAccount,wallet.publicKey,POOL,reward_mint))
 758 |         j++;
 759 |       }
 760 |       
 761 |       instructions.push(
 762 |         await program.instruction.stakehvh(nfts[i].attributes[0].value, {
 763 |           accounts: {
 764 |             owner : wallet.publicKey,
 765 |             pool : POOL,
 766 |             hvhData : hvh_data,
 767 |             stakeState : stakeState,
 768 |             nftMint : nfts[i].mint_address,
 769 |             metadata : metadata,
 770 |             sourceNftAccount : sourceNftAccount,
 771 |             destNftAccount : destNftAccount,
 772 |             sourceSoulsAccount:srcSoulsAccount,
 773 |             destSoulsAccount:destSoulsAccount,
 774 |             tokenProgram : TOKEN_PROGRAM_ID,
 775 |             systemProgram : anchor.web3.SystemProgram.programId,
 776 |             clock : SYSVAR_CLOCK_PUBKEY
 777 |           }
 778 |         })
 779 |       )
 780 | 
 781 |       j++;
 782 | 
 783 |       if(j==3 || (i == nfts.length-1 && j != 0)) {
 784 |         let transaction = new Transaction()
 785 |         instructions.map(item=>transaction.add(item))
 786 |         await sendTransaction(transaction,[])
 787 |         j=0
 788 |         instructions=[]
 789 |         if(i == nfts.length - 1) {
 790 |           setLoading(false);
 791 |           await getNfts();
 792 |         }
 793 |       }
 794 | 
 795 |     }
 796 |   }
 797 | 
 798 | 
 799 |   async function validateStakingSoldier(
 800 |     conn : Connection,
 801 |     owner : PublicKey,
 802 |     hvhtype : String
 803 |     ){
 804 |     console.log("+ validate Staking Souldier")
 805 | 
 806 |     if(!wallet.connected) {
 807 |       notify('error', 'Wallet is unconnected!');
 808 |       // setLoading(false);
 809 |       return false;
 810 |     }
 811 | 
 812 |     const provider = new anchor.Provider(conn, wallet, anchor.Provider.defaultOptions());
 813 |     const program = new anchor.Program(idl, programId, provider);
 814 | 
 815 |     await getPoolData();
 816 | 
 817 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 818 | 
 819 |     let [stakeState] = await getProgramAccount(owner, POOL, reward_mint);
 820 | 
 821 |     let balance = await getTokenAccountBalance(owner, reward_mint);
 822 | 
 823 |     //halos win
 824 |     if(hvhtype == pD.token_halos && pD.prev_win == 0) {
 825 |       if(balance < pD.win_team_stake) {
 826 |         notify('error', 'Insufficient tokens!');
 827 |         // setLoading(false);
 828 |         return false;
 829 |       }
 830 |     } 
 831 | 
 832 |     //horns win
 833 |     if(hvhtype == pD.token_horns && pD.prev_win == 1) {
 834 |       if(balance < pD.lost_team_stake) {
 835 |         notify('error', 'Insufficient tokens!');
 836 |         // setLoading(false);
 837 |         return false;
 838 |       }
 839 |     }
 840 | 
 841 |     //draw
 842 |     if(pD.prev_win == 2) {
 843 |       if(balance < pD.soulAmount) {
 844 |         notify('error', 'Insufficient tokens!');
 845 |         // setLoading(false);
 846 |         return false;
 847 |       }
 848 |     }
 849 | 
 850 |     // console.log(time_period.staking_limit, moment().unix(), time_period.withdraw_limit);
 851 |     
 852 |     if(moment().unix() >= Date.parse(pD.end_time) / 1000 && moment().unix() <= Date.parse(pD.end_withdraw) / 1000) {
 853 |       notify('error', 'Staking period has passed!');
 854 |       // setLoading(false)
 855 |       return false;
 856 |     }
 857 | 
 858 |     if((await conn.getAccountInfo(stakeState)) != null) {
 859 |       stakedinfo = await getStakeStateInfo(stakeState)
 860 |       // console.log(moment().unix(), time_period.staking_limit)
 861 |       if(moment().unix() < Date.parse(pD.end_time) / 1000) {
 862 |         if(stakedinfo.lastStakeTime.toNumber() !== 0 && stakedinfo.lastStakeTime.toNumber() < (Date.parse(pD.start_time) / 1000)) {
 863 |             if(stakedinfo.halosCount.toNumber() != 0 || stakedinfo.hornsCount.toNumber() != 0 || stakedinfo.soldierHalosCount.toNumber() != 0 || stakedinfo.soldierHornsCount.toNumber() != 0) {
 864 |               // console.log("test")
 865 |               notify('error', 'You should claim and unstake nft tokens before stake!');
 866 |               // setLoading(false)
 867 |               return false;
 868 |             }
 869 |         }
 870 |       }
 871 |     }
 872 |       
 873 |     // console.log(starttime, moment().unix(), next_staking_limit)
 874 |     if(moment().unix() > Date.parse(pD.end_withdraw) / 1000) {
 875 |       // console.log("test")
 876 |       notify('error', 'Staking period has passed!');
 877 |       // setLoading(false);
 878 |       return false;
 879 |     }
 880 | 
 881 |     return true;
 882 |   }
 883 | 
 884 |   async function stakeSoldier(
 885 |     nftAccount : PublicKey,
 886 |     nftMint : PublicKey,
 887 |     hvhtype : String
 888 |     ){
 889 | 
 890 |     setLoading(true);
 891 | 
 892 |     if(!await validateStakingSoldier(conn, wallet.publicKey, hvhtype)) {
 893 |       setLoading(false);
 894 |       return;
 895 |     }
 896 | 
 897 |     console.log("+ stake souldiers")
 898 | 
 899 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
 900 |     let program = new anchor.Program(idl,programId,provider)
 901 | 
 902 |     // const stakeData = Keypair.generate()
 903 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 904 |     const metadata = await getMetadata(nftMint)
 905 |     const sourceNftAccount = nftAccount;
 906 |     const destNftAccount = await getTokenWallet(POOL,nftMint)
 907 |     const srcSoulsAccount = await getTokenWallet(wallet.publicKey, reward_mint);
 908 |     const destSoulsAccount = await getTokenWallet(POOL, reward_mint);
 909 | 
 910 |     const accountInfo: any = await conn.getParsedAccountInfo(metadata);
 911 |     let metadata1 : any = new Metadata(wallet.publicKey.toString(), accountInfo.value);
 912 | 
 913 |     let [stakeState, bump] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
 914 |     let [soldier_data, bump1] = await getProgramAccount(wallet.publicKey, POOL, nftMint);
 915 | 
 916 |     let transaction = new Transaction()
 917 |     // signers.push(stakeState)
 918 |     if((await conn.getAccountInfo(destNftAccount)) == null)
 919 |       transaction.add(createAssociatedTokenAccountInstruction(destNftAccount,wallet.publicKey,POOL,nftMint))
 920 |     if((await conn.getAccountInfo(destSoulsAccount)) == null)
 921 |       transaction.add(createAssociatedTokenAccountInstruction(destSoulsAccount,wallet.publicKey,POOL,reward_mint))
 922 |     if((await conn.getAccountInfo(soldier_data)) == null) {
 923 |       transaction.add(
 924 |         await program.instruction.initSoldierData(new anchor.BN(bump1),
 925 |         {
 926 |           accounts: {
 927 |             owner : wallet.publicKey,
 928 |             pool : POOL,
 929 |             nftMint: nftMint,
 930 |             soldierData: soldier_data,
 931 |             systemProgram : anchor.web3.SystemProgram.programId
 932 |           }
 933 |         })
 934 |       )
 935 |     }
 936 | 
 937 |     if((await conn.getAccountInfo(stakeState)) == null) {
 938 |       transaction.add(
 939 |         await program.instruction.initStakeState(new anchor.BN(bump),
 940 |         {
 941 |           accounts: {
 942 |             owner : wallet.publicKey,
 943 |             pool : POOL,
 944 |             soulsMint: reward_mint,
 945 |             stakeState: stakeState,
 946 |             systemProgram : anchor.web3.SystemProgram.programId
 947 |           }
 948 |         })
 949 |       )
 950 |     }
 951 | 
 952 |     let signers : Keypair[] = []
 953 |     // signers.push(stakeData)
 954 |     transaction.add(
 955 |       await program.instruction.stakesoldiers(hvhtype, {
 956 |         accounts: {
 957 |           owner : wallet.publicKey,
 958 |           pool : POOL,
 959 |           soldierData : soldier_data,
 960 |           stakeState : stakeState,
 961 |           nftMint : nftMint,
 962 |           metadata : metadata,
 963 |           sourceNftAccount : sourceNftAccount,
 964 |           destNftAccount : destNftAccount,
 965 |           sourceSoulsAccount:srcSoulsAccount,
 966 |           destSoulsAccount:destSoulsAccount,
 967 |           tokenProgram : TOKEN_PROGRAM_ID,
 968 |           systemProgram : anchor.web3.SystemProgram.programId,
 969 |           clock : SYSVAR_CLOCK_PUBKEY
 970 |         }
 971 |       })
 972 |     )
 973 | 
 974 |     await sendTransaction(transaction,signers)
 975 | 
 976 |     setLoading(false);
 977 |     await getNfts();
 978 | 
 979 |   }
 980 | 
 981 |   async function stakeSoldiersAll(hvhtype : String){
 982 | 
 983 |     setLoading(true);
 984 | 
 985 |     if(soldiers.length <= 0) {
 986 |       setLoading(false);
 987 |       return;
 988 |     }
 989 | 
 990 |     console.log("+ stake souldier All")
 991 | 
 992 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
 993 |     let program = new anchor.Program(idl,programId,provider)
 994 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
 995 |     let [stakeState, bump] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
 996 | 
 997 |     let stakeData = null;
 998 |     let metadata = null;
 999 |     let sourceNftAccount = null;
1000 |     let destNftAccount = null;
1001 |     let srcSoulsAccount = null;
1002 |     let destSoulsAccount = null;
1003 | 
1004 |     let accountInfo: any = null;
1005 |     let metadata1 : any = null;
1006 |     // nft.account_address, nft.mint_address, nft.attributes[0].value
1007 | 
1008 |     // let instructions : TransactionInstruction[] = []
1009 | 
1010 |     let transactiona = new Transaction()
1011 |     
1012 |     if((await conn.getAccountInfo(stakeState)) == null) {
1013 |       transactiona.add(
1014 |         await program.instruction.initStakeState(new anchor.BN(bump),
1015 |         {
1016 |           accounts: {
1017 |             owner : wallet.publicKey,
1018 |             pool : POOL,
1019 |             soulsMint: reward_mint,
1020 |             stakeState: stakeState,
1021 |             systemProgram : anchor.web3.SystemProgram.programId
1022 |           }
1023 |         })
1024 |         )
1025 |         await sendTransaction(transactiona, [])
1026 |     }
1027 |          
1028 |     let instructions : TransactionInstruction[] = []
1029 |     // let transaction = new Transaction()
1030 |     // let signers : Keypair[] = []
1031 |     let j = 0;
1032 | 
1033 |     if(!await validateStakingSoldier(conn, wallet.publicKey,hvhtype)) {
1034 |       // await getNfts();
1035 |       setLoading(false);
1036 |       return;
1037 |     }
1038 |     
1039 |     let i = 0;
1040 | 
1041 |     for(i = 0; i < soldiers.length; i++) {
1042 | 
1043 |       metadata = await getMetadata(soldiers[i].mint_address)  
1044 |       sourceNftAccount = soldiers[i].account_address   
1045 |       destNftAccount = await getTokenWallet(POOL, soldiers[i].mint_address) 
1046 |       srcSoulsAccount = await getTokenWallet(wallet.publicKey, reward_mint)  
1047 |       destSoulsAccount = await getTokenWallet(POOL, reward_mint);
1048 |       
1049 |       accountInfo = await conn.getParsedAccountInfo(metadata);
1050 |       metadata1 = new Metadata(wallet.publicKey.toString(), accountInfo.value);
1051 |  
1052 |       let [soldier_data, bump1] = await getProgramAccount(wallet.publicKey, POOL, soldiers[i].mint_address);
1053 | 
1054 |       if((await conn.getAccountInfo(soldier_data)) == null) {
1055 |         instructions.push(
1056 |           await program.instruction.initSoldierData(new anchor.BN(bump1),
1057 |           {
1058 |             accounts: {
1059 |               owner : wallet.publicKey,
1060 |               pool : POOL,
1061 |               nftMint: soldiers[i].mint_address,
1062 |               soldierData: soldier_data,
1063 |               systemProgram : anchor.web3.SystemProgram.programId
1064 |             }
1065 |           })
1066 |         )
1067 |         j++;
1068 |       }
1069 | 
1070 | 
1071 |       if((await conn.getAccountInfo(destNftAccount)) == null) {
1072 |         instructions.push(createAssociatedTokenAccountInstruction(destNftAccount,wallet.publicKey,POOL, soldiers[i].mint_address))
1073 |         j++;
1074 |       }
1075 |       if((await conn.getAccountInfo(destSoulsAccount)) == null) {
1076 |         instructions.push(createAssociatedTokenAccountInstruction(destSoulsAccount,wallet.publicKey,POOL,reward_mint))
1077 |         j++;
1078 |       }
1079 |       
1080 |       instructions.push(
1081 |         await program.instruction.stakesoldiers(hvhtype, {
1082 |           accounts: {
1083 |             owner : wallet.publicKey,
1084 |             pool : POOL,
1085 |             soldierData : soldier_data,
1086 |             stakeState : stakeState,
1087 |             nftMint : soldiers[i].mint_address,
1088 |             metadata : metadata,
1089 |             sourceNftAccount : sourceNftAccount,
1090 |             destNftAccount : destNftAccount,
1091 |             sourceSoulsAccount:srcSoulsAccount,
1092 |             destSoulsAccount:destSoulsAccount,
1093 |             tokenProgram : TOKEN_PROGRAM_ID,
1094 |             systemProgram : anchor.web3.SystemProgram.programId,
1095 |             clock : SYSVAR_CLOCK_PUBKEY
1096 |           }
1097 |         })
1098 |       )
1099 | 
1100 |       j++;
1101 | 
1102 |       if(j==3 || (i == soldiers.length-1 && j != 0)) {
1103 |         let transaction = new Transaction()
1104 |         instructions.map(item=>transaction.add(item))
1105 |         await sendTransaction(transaction,[])
1106 | 
1107 |         j=0
1108 |         instructions=[]
1109 | 
1110 |         if(i == soldiers.length - 1) {
1111 |           setLoading(false);
1112 |           await getNfts();
1113 |         }
1114 |       }
1115 |     }
1116 |   }
1117 | 
1118 |   async function validateUnStaking(stakedatainfo : any){
1119 |     console.log("+ validate UnStaking")
1120 | 
1121 |     if(!wallet.connected) {
1122 |       notify('error', 'Wallet is unconnected!');
1123 |       // setLoading(false);
1124 |       return false;
1125 |     }
1126 | 
1127 |     if(stakedatainfo.unstaked) {
1128 |       notify('error', 'Already unstaked!');
1129 |       // setLoading(false);
1130 |       return false;
1131 |     }
1132 | 
1133 |     await getPoolData();
1134 | 
1135 |     if(moment().unix() <= Date.parse(pD.end_time) / 1000) {
1136 |       notify('error', 'Please wait until the weekly staking competition is complete!');
1137 |       // setLoading(false);
1138 |       return false;
1139 |     }
1140 | 
1141 |     return true;
1142 |   }
1143 | 
1144 |   async function unstake(
1145 |     stakeData : PublicKey,
1146 |     hvhtype : String
1147 |     ){
1148 | 
1149 |     setLoading(true);
1150 | 
1151 |     let stakedatainfo = await getStakeDataInfo(stakeData);
1152 |     if(!await validateUnStaking(stakedatainfo)) {
1153 |       setLoading(false)
1154 |       return;
1155 |     }
1156 |     console.log("+ unstake")
1157 | 
1158 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
1159 |     let program = new anchor.Program(idl,programId,provider)
1160 |     let stakedNft = await program.account.hvHData.fetch(stakeData)
1161 |     let account = await conn.getAccountInfo(stakedNft.nftAccount)
1162 |     let mint = new PublicKey(AccountLayout.decode(account!.data).mint)
1163 |     const sourceNftAccount = await getTokenWallet(POOL, mint);
1164 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
1165 |     let [stakeState,] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
1166 |     const metadata = await getMetadata(mint)
1167 | 
1168 |     let transaction = new Transaction()
1169 | 
1170 |     transaction.add(
1171 |       await program.instruction.unstakehvh(hvhtype,
1172 |         {
1173 |         accounts:{
1174 |           owner : wallet.publicKey,
1175 |           pool : POOL,
1176 |           hvhData : stakeData,
1177 |           stakeState : stakeState,
1178 |           nftMint : mint,
1179 |           metadata : metadata,
1180 |           sourceNftAccount : sourceNftAccount,
1181 |           destNftAccount : stakedNft.nftAccount,
1182 |           tokenProgram : TOKEN_PROGRAM_ID,
1183 |           systemProgram : anchor.web3.SystemProgram.programId,
1184 |           clock : SYSVAR_CLOCK_PUBKEY
1185 |         }
1186 |       })
1187 |     )
1188 | 
1189 |     await sendTransaction(transaction,[])
1190 | 
1191 |     setLoading(false);
1192 |     await getNfts();
1193 | 
1194 |   }
1195 | 
1196 |   async function unstakeAll(){
1197 | 
1198 |     setLoading(true);
1199 | 
1200 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
1201 |     let program = new anchor.Program(idl,programId,provider)
1202 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
1203 |     let [stakeState] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
1204 |     let stakedNFTs = await getStakedNftsForOwner(conn,wallet.publicKey)
1205 | 
1206 |     console.log("+unstake all");
1207 | 
1208 |     let j = 0;
1209 |     let stakedNft = null;
1210 |     let account = null;
1211 |     let mint = null;
1212 |     let sourceNftAccount = null;
1213 |     let metadata = null;
1214 |     let stakeData = null;
1215 |     let stakedatainfo = null;
1216 |     let instructions : TransactionInstruction[] = []
1217 | 
1218 |     if(stakedNFTs.length <= 0) {
1219 |       setLoading(false);
1220 |       return;
1221 |     }
1222 | 
1223 |     let i = 0;
1224 | 
1225 |     for(i = 0; i < stakedNFTs.length; i++) {
1226 |       stakeData = stakedNFTs[i].stakeData;
1227 |       stakedatainfo = await getStakeDataInfo(stakeData);
1228 |       if(!await validateUnStaking(stakedatainfo)) {
1229 |         // await getNfts();
1230 |         setLoading(false);
1231 |         return;
1232 |       }
1233 | 
1234 |       stakedNft = await program.account.hvHData.fetch(stakeData)
1235 |       account = await conn.getAccountInfo(stakedNft.nftAccount)
1236 |       mint = new PublicKey(AccountLayout.decode(account!.data).mint)
1237 |       sourceNftAccount = await getTokenWallet(POOL, mint);
1238 |       metadata = await getMetadata(mint)
1239 | 
1240 |       instructions.push(
1241 |         await program.instruction.unstakehvh(stakedNFTs[i].type,
1242 |           {
1243 |           accounts:{
1244 |             owner : wallet.publicKey,
1245 |             pool : POOL,
1246 |             hvhData : stakeData,
1247 |             stakeState : stakeState,
1248 |             nftMint : mint,
1249 |             metadata : metadata,
1250 |             sourceNftAccount : sourceNftAccount,
1251 |             destNftAccount : stakedNft.nftAccount,
1252 |             tokenProgram : TOKEN_PROGRAM_ID,
1253 |             systemProgram : anchor.web3.SystemProgram.programId,
1254 |             clock : SYSVAR_CLOCK_PUBKEY
1255 |           }
1256 |         })
1257 |       )
1258 |       
1259 |       j++;
1260 | 
1261 |       if((j === 4) || (i === stakedNFTs.length - 1 && j !== 0)) {
1262 | 
1263 |         let transaction = new Transaction()
1264 |         
1265 |         instructions.map(item=>transaction.add(item))
1266 |         
1267 |         await sendTransaction(transaction, []);
1268 | 
1269 |         j = 0;
1270 |         instructions = []
1271 | 
1272 |         if (i == stakedNFTs.length - 1) {
1273 |           setLoading(false);
1274 |           await getNfts();
1275 |         }
1276 | 
1277 |       }
1278 |     }   
1279 |     // await sendSingleTransaction(transaction,[])
1280 |   }
1281 | 
1282 |   async function validateUnStakingSoldier(stakedatainfo : any){
1283 |     console.log("+ validate UnStaking Souldier")
1284 | 
1285 |     if(!wallet.connected) {
1286 |       notify('error', 'Wallet is unconnected!');
1287 |       // setLoading(false);
1288 |       return false;
1289 |     }
1290 | 
1291 |     if(stakedatainfo.unstaked) {
1292 |       notify('error', 'Already unstaked!');
1293 |       // setLoading(false);
1294 |       return false;
1295 |     }
1296 | 
1297 |     await getPoolData();
1298 | 
1299 |     if(moment().unix() <= Date.parse(pD.end_time) / 1000) {
1300 |       notify('error', 'Please wait until the weekly staking competition is complete!');
1301 |       // setLoading(false);
1302 |       return false;
1303 |     }
1304 | 
1305 |     return true;
1306 |   }
1307 | 
1308 |   async function unstakesoldier(
1309 |     stakeData : PublicKey,
1310 |     hvhtype : String
1311 |     ){
1312 | 
1313 |     setLoading(true);
1314 | 
1315 |     let stakedatainfo = await getSoldierDataInfo(stakeData);
1316 |     if(!await validateUnStakingSoldier(stakedatainfo)) {
1317 |       setLoading(false)
1318 |       return;
1319 |     }
1320 |     console.log("+ unstake souldier")
1321 | 
1322 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
1323 |     let program = new anchor.Program(idl,programId,provider)
1324 |     let stakedNft = await program.account.soldierData.fetch(stakeData)
1325 |     let account = await conn.getAccountInfo(stakedNft.nftAccount)
1326 |     let mint = new PublicKey(AccountLayout.decode(account!.data).mint)
1327 |     const sourceNftAccount = await getTokenWallet(POOL, mint);
1328 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
1329 |     let [stakeState,] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
1330 |     const metadata = await getMetadata(mint)
1331 | 
1332 |     let transaction = new Transaction()
1333 | 
1334 |     transaction.add(
1335 |       await program.instruction.unstakesoldier(
1336 |         {
1337 |         accounts:{
1338 |           owner : wallet.publicKey,
1339 |           pool : POOL,
1340 |           soldierData : stakeData,
1341 |           stakeState : stakeState,
1342 |           nftMint : mint,
1343 |           metadata : metadata,
1344 |           sourceNftAccount : sourceNftAccount,
1345 |           destNftAccount : stakedNft.nftAccount,
1346 |           tokenProgram : TOKEN_PROGRAM_ID,
1347 |           systemProgram : anchor.web3.SystemProgram.programId,
1348 |           clock : SYSVAR_CLOCK_PUBKEY
1349 |         }
1350 |       })
1351 |     )
1352 | 
1353 |     await sendTransaction(transaction,[])
1354 | 
1355 |     setLoading(false);
1356 |     await getNfts();
1357 | 
1358 |   }
1359 | 
1360 |   async function unstakeSoldiersAll(){
1361 | 
1362 |     setLoading(true);
1363 | 
1364 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
1365 |     let program = new anchor.Program(idl,programId,provider)
1366 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
1367 |     let [stakeState] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
1368 |     let stakedNFTs = await getStakedSoldiersForOwner(conn,wallet.publicKey)
1369 | 
1370 |     console.log("+unstake souldiers all");
1371 | 
1372 |     let j = 0;
1373 |     let stakedNft = null;
1374 |     let account = null;
1375 |     let mint = null;
1376 |     let sourceNftAccount = null;
1377 |     let metadata = null;
1378 |     let stakeData = null;
1379 |     let stakedatainfo = null;
1380 |     let instructions : TransactionInstruction[] = []
1381 | 
1382 |     if(stakedNFTs.length <= 0) {
1383 |       setLoading(false);
1384 |       return;
1385 |     }
1386 | 
1387 |     let i = 0;
1388 | 
1389 |     for(i = 0; i < stakedNFTs.length; i++) {
1390 |       stakeData = stakedNFTs[i].stakeData;
1391 |       stakedatainfo = await getSoldierDataInfo(stakeData);
1392 |       if(!await validateUnStakingSoldier(stakedatainfo)) {
1393 |         // await getNfts();
1394 |         setLoading(false);
1395 |         return;
1396 |       }
1397 | 
1398 |       stakedNft = await program.account.soldierData.fetch(stakeData)
1399 |       account = await conn.getAccountInfo(stakedNft.nftAccount)
1400 |       mint = new PublicKey(AccountLayout.decode(account!.data).mint)
1401 |       sourceNftAccount = await getTokenWallet(POOL, mint);
1402 |       metadata = await getMetadata(mint)
1403 | 
1404 |       instructions.push(
1405 |         await program.instruction.unstakesoldier(
1406 |           {
1407 |           accounts:{
1408 |             owner : wallet.publicKey,
1409 |             pool : POOL,
1410 |             soldierData : stakeData,
1411 |             stakeState : stakeState,
1412 |             nftMint : mint,
1413 |             metadata : metadata,
1414 |             sourceNftAccount : sourceNftAccount,
1415 |             destNftAccount : stakedNft.nftAccount,
1416 |             tokenProgram : TOKEN_PROGRAM_ID,
1417 |             systemProgram : anchor.web3.SystemProgram.programId,
1418 |             clock : SYSVAR_CLOCK_PUBKEY
1419 |           }
1420 |         })
1421 |       )
1422 |       
1423 |       j++;
1424 | 
1425 |       if((j === 4) || (i === stakedNFTs.length - 1 && j !== 0)) {
1426 | 
1427 |         let transaction = new Transaction()
1428 |         
1429 |         instructions.map(item=>transaction.add(item))
1430 |         
1431 |         await sendTransaction(transaction, []);
1432 | 
1433 |         j = 0;
1434 |         instructions = []
1435 | 
1436 |         if(i === stakedNFTs.length - 1) {
1437 |           await getNfts();
1438 |           setLoading(false);
1439 |         }
1440 | 
1441 |       }
1442 |     }    
1443 |     // await sendSingleTransaction(transaction,[])
1444 |   }
1445 | 
1446 |   async function validateClaim(stakestateinfo : any){
1447 |     console.log("+ validate UnStaking")
1448 | 
1449 |     if(!wallet.connected) {
1450 |       notify('error', 'Wallet is unconnected!');
1451 |       // setLoading(false);
1452 |       return false;
1453 |     }
1454 | 
1455 |     await getPoolData();
1456 | 
1457 |     if(moment().unix() <= Date.parse(pD.end_time) / 1000 || moment().unix() > Date.parse(pD.end_withdraw) / 1000) {
1458 |       notify('error', 'Not withdraw period!');
1459 |       return false;
1460 |     }
1461 | 
1462 |     if(stakestateinfo.lastStakeTime.toNumber() <= Date.parse(pD.start_time) / 1000) {
1463 |       notify('error', 'You should stake again!');
1464 |       return false;
1465 |     }
1466 | 
1467 |     if(stakestateinfo.claimed) {
1468 |       notify('error', 'Already claimed!');
1469 |       return false;
1470 |     }
1471 | 
1472 |     return true;
1473 |   }
1474 | 
1475 |   async function claim(
1476 |     ){
1477 |     console.log("+ claim")
1478 | 
1479 |     setLoading(true);
1480 | 
1481 |     let provider = new anchor.Provider(conn, wallet as any, confirmOption)
1482 |     let program = new anchor.Program(idl,programId,provider)  
1483 | 
1484 |     const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
1485 |     let [stakeState] = await getProgramAccount(wallet.publicKey, POOL, reward_mint);
1486 |     // console.log("test")
1487 |     if((await conn.getAccountInfo(stakeState)) === null) {
1488 |       notify('error', 'Nothing staked!');
1489 |       setLoading(false);
1490 |       return false;
1491 |     }
1492 | 
1493 |     // console.log("test")
1494 | 
1495 |     let stakedinfo = await getStakeStateInfo(stakeState);
1496 | 
1497 |     if(!await validateClaim(stakedinfo)) {
1498 |       setLoading(false);
1499 |       return;
1500 |     }
1501 | 
1502 |     const destSoulsAccount = await getTokenWallet(wallet.publicKey, reward_mint);
1503 |     const srcSoulsAccount = await getTokenWallet(POOL, reward_mint);
1504 | 
1505 |     let transaction = new Transaction()
1506 | 
1507 |     if((await conn.getAccountInfo(destSoulsAccount)) == null)
1508 |       transaction.add(createAssociatedTokenAccountInstruction(destSoulsAccount, wallet.publicKey, wallet.publicKey, reward_mint))
1509 | 
1510 |     transaction.add(
1511 |       await program.instruction.claim({
1512 |         accounts:{
1513 |           owner : wallet.publicKey,
1514 |           pool : POOL,
1515 |           stakeState : stakeState,
1516 |           destSoulsAccount : destSoulsAccount,
1517 |           sourceSoulsAccount : srcSoulsAccount,
1518 |           burnSoulsAccount : srcSoulsAccount,
1519 |           tokenProgram : TOKEN_PROGRAM_ID,
1520 |           systemProgram : anchor.web3.SystemProgram.programId,
1521 |           clock : SYSVAR_CLOCK_PUBKEY,
1522 |         }
1523 |       })
1524 |     )
1525 |     // }
1526 | 
1527 |     await sendTransaction(transaction,[])
1528 | 
1529 |     setLoading(false);
1530 |   
1531 |   }
1532 | 
1533 |   async function getNftsForOwner(
1534 |     conn : any,
1535 | 	  owner : PublicKey
1536 | 	  ){
1537 | 
1538 |       console.log("+ getNftsForOwner")
1539 | 
1540 | 		const verifiednfts: any = []
1541 | 
1542 | 		const allnfts: any = [];
1543 | 
1544 |     const nftaccounts : any = [];
1545 | 
1546 | 		// const randWallet = new anchor.Wallet(Keypair.generate())
1547 | 		// const provider = new anchor.Provider(conn,randWallet,confirmOption)
1548 | 		// const program = new anchor.Program(idl,programId,provider)
1549 | 
1550 | 		const tokenAccounts = await conn.getParsedTokenAccountsByOwner(owner, {programId: TOKEN_PROGRAM_ID});
1551 | 
1552 | 		let tokenAccount, tokenAmount;
1553 | 
1554 | 		for (let index = 0; index < tokenAccounts.value.length; index++) {
1555 | 			tokenAccount = tokenAccounts.value[index];
1556 | 			tokenAmount = tokenAccount.account.data.parsed.info.tokenAmount;
1557 | 			if (tokenAmount.amount == '1' && tokenAmount.decimals == 0) {
1558 | 				const nftMint = new PublicKey(tokenAccount.account.data.parsed.info.mint)
1559 | 				let tokenmetaPubkey = await Metadata.getPDA(nftMint);
1560 | 				allnfts.push(tokenmetaPubkey);
1561 |         nftaccounts.push(tokenAccounts.value[index].pubkey)
1562 | 			}
1563 | 		}
1564 | 
1565 |     let nftinfo: any[] = [];
1566 |     const buffer = [...allnfts];
1567 |     let count = 100;
1568 |     while(buffer.length > 0) {
1569 |       if(buffer.length < 100) {
1570 |         count = buffer.length;
1571 |       } else {
1572 |         count = 100;
1573 |       }
1574 |       nftinfo = [...nftinfo.concat(await conn.getMultipleAccountsInfo(buffer.splice(0, count)))];
1575 |     }
1576 | 
1577 | 		// const nftinfo: any = await conn.getMultipleAccountsInfo(allnfts);
1578 | 
1579 | 		// let tokenCount = nftinfo.length
1580 | 
1581 | 		for(let i = 0; i < nftinfo.length; i++) {
1582 | 
1583 |       if(nftinfo[i] == null) {
1584 |         continue;
1585 |       }
1586 |       
1587 | 			let metadata : any = new Metadata(owner.toString(), nftinfo[i])
1588 | 
1589 | 			if(metadata.data.data.symbol == pD.hvh_symbol) {
1590 | 
1591 |         let data: any;
1592 | 
1593 | 				try {
1594 |           data = await axios.get(metadata.data.data.uri, {timeout: axios_timeout});
1595 |         } catch(error) {
1596 |           console.log(error);
1597 |           continue;
1598 |         }
1599 | 
1600 |         // console.log("data loaded", data)
1601 | 
1602 |         if(!data) {
1603 |           // console.log("data error")
1604 |           continue;
1605 |         }
1606 | 
1607 | 				const entireData = { ...data.data, id: Number(data.data.name.replace( /^\D+/g, '').split(' - ')[0])}
1608 | 
1609 |         let nftMint = new PublicKey(metadata.data.mint)
1610 |         if(entireData.attributes.value === pD.halos || entireData.attributes.value === pD.horns) {
1611 |           verifiednfts.push({account_address : nftaccounts[i], mint_address : nftMint, ...entireData})
1612 |         }
1613 | 			}
1614 | 		}
1615 | 
1616 |     verifiednfts.sort(function (a: any, b: any) {
1617 |       if (a.name < b.name) { return -1; }
1618 |       if (a.name > b.name) { return 1; }
1619 |       return 0;
1620 |     })
1621 | 
1622 | 		return verifiednfts
1623 | 	}
1624 | 
1625 |   async function getSoldiersForOwner(
1626 |     conn : any,
1627 | 	  owner : PublicKey
1628 | 	  ){
1629 | 
1630 |     console.log("+ getSouldiersForOwner")
1631 | 
1632 | 		const verifiednfts: any = []
1633 | 
1634 | 		const allnfts: any = [];
1635 | 
1636 |     const nftaccounts: any = [];
1637 | 
1638 | 		// const randWallet = new anchor.Wallet(Keypair.generate())
1639 | 		// const provider = new anchor.Provider(conn,randWallet,confirmOption)
1640 | 		// const program = new anchor.Program(idl,programId,provider)
1641 | 
1642 | 		const tokenAccounts = await conn.getParsedTokenAccountsByOwner(owner, {programId: TOKEN_PROGRAM_ID});
1643 | 
1644 | 		let tokenAccount, tokenAmount;
1645 | 
1646 | 		for (let index = 0; index < tokenAccounts.value.length; index++) {
1647 | 			tokenAccount = tokenAccounts.value[index];
1648 | 			tokenAmount = tokenAccount.account.data.parsed.info.tokenAmount;
1649 | 			if (tokenAmount.amount == '1' && tokenAmount.decimals == 0) {
1650 | 				const nftMint = new PublicKey(tokenAccount.account.data.parsed.info.mint)
1651 | 				let tokenmetaPubkey = await Metadata.getPDA(nftMint);
1652 | 				allnfts.push(tokenmetaPubkey);
1653 |         nftaccounts.push(tokenAccounts.value[index].pubkey)
1654 | 			}
1655 | 		}
1656 | 
1657 |     let nftinfo: any[] = [];
1658 |     const buffer = [...allnfts];
1659 |     let count = 100;
1660 |     while(buffer.length > 0) {
1661 |       if(buffer.length < 100) {
1662 |         count = buffer.length;
1663 |       } else {
1664 |         count = 100;
1665 |       }
1666 |       nftinfo = [...nftinfo.concat(await conn.getMultipleAccountsInfo(buffer.splice(0, count)))];
1667 |     }
1668 | 
1669 | 		// const nftinfo: any = await conn.getMultipleAccountsInfo(allnfts);
1670 | 
1671 | 		// let tokenCount = nftinfo.length
1672 | 
1673 | 		for(let i = 0; i < nftinfo.length; i++) {
1674 | 
1675 |       if(nftinfo[i] == null) {
1676 |         continue;
1677 |       }
1678 |       
1679 | 			let metadata : any = new Metadata(owner.toString(), nftinfo[i])
1680 | 
1681 | 			if(metadata.data.data.symbol == pD.soldier_symbol) {
1682 | 
1683 |         // console.log("get data")
1684 | 
1685 |         let data: any;
1686 | 
1687 | 				try {
1688 |           data = await axios.get(metadata.data.data.uri, {timeout: axios_timeout});
1689 |         } catch(error) {
1690 |           console.log(error);
1691 |           continue;
1692 |         }
1693 | 
1694 |         // console.log("data loaded", data)
1695 | 
1696 |         if(!data) {
1697 |           // console.log("data error")
1698 |           continue;
1699 |         }
1700 | 
1701 | 				const entireData = { ...data.data, id: Number(data.data.name.replace( /^\D+/g, '').split(' - ')[0])}
1702 | 
1703 |         // console.log("data", entireData);
1704 | 
1705 |         let nftMint = new PublicKey(metadata.data.mint)
1706 |         if(entireData.attributes.value === pD.halos || entireData.attributes.value === pD.horns) {
1707 |           // console.log("mint", nftaccounts[i].toBase58(), nftMint.toBase58())
1708 |           verifiednfts.push({account_address : nftaccounts[i], mint_address : nftMint, ...entireData})
1709 |         }
1710 | 			}
1711 | 		}
1712 | 
1713 |     verifiednfts.sort(function (a: any, b: any) {
1714 |       if (a.name < b.name) { return -1; }
1715 |       if (a.name > b.name) { return 1; }
1716 |       return 0;
1717 |     })
1718 | 
1719 | 		return verifiednfts
1720 | 	}
1721 | 
1722 |   async function getStakedNftsForOwner(
1723 |     conn : any,
1724 | 	  owner : PublicKey
1725 | 	  ){
1726 | 
1727 |     console.log("+ getStakedNftsForOwner")
1728 | 
1729 | 		const verifiednfts: any = [];
1730 | 
1731 | 		const allnfts: any = [];
1732 | 
1733 |     const stakedNfts: any = [];
1734 | 
1735 | 		const randWallet = new anchor.Wallet(Keypair.generate())
1736 | 		const provider = new anchor.Provider(conn,randWallet,confirmOption)
1737 | 		const program = new anchor.Program(idl,programId,provider)
1738 | 
1739 | 		let resp = await conn.getProgramAccounts(programId,{
1740 |       dataSlice: {length: 0, offset: 0},
1741 |       filters: [{dataSize: 8 + HVH_DATA_SIZE},{memcmp:{offset:8,bytes:owner.toBase58()}},{memcmp:{offset:40,bytes:POOL.toBase58()}}]
1742 |     })
1743 | 
1744 |     let stakedNft: any;
1745 | 
1746 | 		for (let index = 0; index < resp.length; index++) {
1747 |       stakedNft = await program.account.hvHData.fetch(resp[index].pubkey);
1748 |       if(stakedNft.unstaked) continue;
1749 |       const nftMint = new PublicKey(stakedNft.nftMint)
1750 |       let tokenmetaPubkey = await Metadata.getPDA(nftMint);
1751 |       allnfts.push(tokenmetaPubkey);
1752 |       stakedNfts.push({data: stakedNft, account: resp[index].pubkey});
1753 | 		}
1754 | 
1755 |     let nftinfo: any[] = [];
1756 |     const buffer = [...allnfts];
1757 |     let count = 100;
1758 |     while(buffer.length > 0) {
1759 |       if(buffer.length < 100) {
1760 |         count = buffer.length;
1761 |       } else {
1762 |         count = 100;
1763 |       }
1764 |       nftinfo = [...nftinfo.concat(await conn.getMultipleAccountsInfo(buffer.splice(0, count)))];
1765 |     }
1766 | 
1767 | 		// const nftinfo: any = await conn.getMultipleAccountsInfo(allnfts);
1768 | 
1769 | 		// let tokenCount = nftinfo.length
1770 | 
1771 | 		for(let i = 0; i < nftinfo.length; i++) {
1772 | 
1773 |       if(nftinfo[i] == null) {
1774 |         continue;
1775 |       }
1776 |       
1777 | 			let metadata : any = new Metadata(owner.toString(), nftinfo[i])
1778 | 
1779 |       // console.log("get data")
1780 | 
1781 |       let data: any;
1782 | 
1783 |       try {
1784 |         data = await axios.get(metadata.data.data.uri, {timeout: axios_timeout});
1785 |       } catch(error) {
1786 |         console.log(error);
1787 |         continue;
1788 |       }
1789 | 
1790 |       // console.log("data loaded", data)
1791 | 
1792 |       if(!data) {
1793 |         // console.log("data error")
1794 |         continue;
1795 |       }
1796 | 
1797 |       const entireData = { ...data.data, id: Number(data.data.name.replace( /^\D+/g, '').split(' - ')[0])}
1798 | 
1799 |       // console.log("data", entireData);
1800 | 
1801 |       let nftMint = new PublicKey(metadata.data.mint)
1802 | 
1803 |       // console.log("account", stakedNfts[i].account.toBase58(), nftMint.toBase58())
1804 | 
1805 |       // verifiednfts.push({account_address : tokenAccounts.value[i].pubkey, mint_address : nftMint, ...entireData})
1806 |       verifiednfts.push({
1807 |         stakeTime : stakedNft.stakeTime.toNumber(),
1808 |         stakeData : stakedNfts[i].account,
1809 |         name : entireData.name,
1810 |         type : entireData.attributes[0].value,
1811 |         ...entireData,
1812 |       })
1813 | 		}
1814 | 
1815 |     verifiednfts.sort(function (a: any, b: any) {
1816 |       if (a.name < b.name) { return -1; }
1817 |       if (a.name > b.name) { return 1; }
1818 |       return 0;
1819 |     })
1820 | 
1821 | 		return verifiednfts
1822 | 	}
1823 | 
1824 |   // async function getStakedNftsForOwner(
1825 |   //   conn : Connection,
1826 |   //   owner : PublicKey,
1827 |   //   ){
1828 |   //   console.log("+ getStakedNftsForOwner")
1829 |   //   const wallet = new anchor.Wallet(Keypair.generate());
1830 |   //   const provider = new anchor.Provider(conn, wallet, anchor.Provider.defaultOptions());
1831 |   //   const program = new anchor.Program(idl, programId, provider);
1832 |   //   const allTokens: any = []
1833 |   //   let resp = await conn.getProgramAccounts(programId,{
1834 |   //     dataSlice: {length: 0, offset: 0},
1835 |   //     filters: [{dataSize: 8 + HVH_DATA_SIZE},{memcmp:{offset:8,bytes:owner.toBase58()}},{memcmp:{offset:40,bytes:POOL.toBase58()}}]
1836 |   //   })
1837 | 
1838 |   //   // const tokenAccounts = await conn.getParsedTokenAccountsByOwner(owner, {programId: TOKEN_PROGRAM_ID});
1839 | 
1840 | 	// 	// const nftinfo: any = await conn.getMultipleAccountsInfo(allnfts);
1841 | 
1842 |   //   for (let index = 0; index < resp.length; index++) {
1843 |   //     try {
1844 |   //       let stakedNft = await program.account.hvHData.fetch(resp[index].pubkey)
1845 | 
1846 |   //       if(stakedNft.unstaked) continue;
1847 |   //       // let account = await conn.getAccountInfo(stakedNft.nftAccount)
1848 | 
1849 |   //       // let mint = new PublicKey(AccountLayout.decode(account!.data).mint)
1850 |   //       let pda= await getMetadata(stakedNft.nftMint)
1851 |   //       const accountInfo: any = await conn.getParsedAccountInfo(pda);
1852 |   //       let metadata : any = new Metadata(owner.toString(), accountInfo.value);
1853 |   //       const { data }: any = await axios.get(metadata.data.data.uri, {timeout: axios_timeout})
1854 |   //       const entireData = { ...data, id: Number(data.name.replace( /^\D+/g, '').split(' - ')[0])}
1855 |   //       // console.log(entireData);
1856 |   //       allTokens.push({
1857 |   //         stakeTime : stakedNft.stakeTime.toNumber(),
1858 |   //         stakeData : resp[index].pubkey,
1859 |   //         name : entireData.name,
1860 |   //         type : entireData.attributes[0].value,
1861 |   //         ...entireData,
1862 |   //       })
1863 | 
1864 |   //       // if(index == resp.length - 1) {
1865 |   //       //   console.log("test")
1866 |   //       //   return allTokens
1867 |   //       // }
1868 |   //     } catch(error) {
1869 |   //       console.log(error)
1870 |   //       continue
1871 |   //     }
1872 |   //   }
1873 | 
1874 |   //   return allTokens
1875 |   // }
1876 | 
1877 |   async function getStakedSoldiersForOwner(
1878 |     conn : any,
1879 | 	  owner : PublicKey
1880 | 	  ){
1881 | 
1882 |     console.log("+ getStakedNftsForOwner")
1883 | 
1884 | 		const verifiednfts: any = [];
1885 | 
1886 | 		const allnfts: any = [];
1887 | 
1888 |     const stakedNfts: any = [];
1889 | 
1890 | 		const randWallet = new anchor.Wallet(Keypair.generate())
1891 | 		const provider = new anchor.Provider(conn,randWallet,confirmOption)
1892 | 		const program = new anchor.Program(idl,programId,provider)
1893 | 
1894 | 		let resp = await conn.getProgramAccounts(programId,{
1895 |       dataSlice: {length: 0, offset: 0},
1896 |       filters: [{dataSize: 8 + SOLDIER_DATA_SIZE},{memcmp:{offset:8,bytes:owner.toBase58()}},{memcmp:{offset:40,bytes:POOL.toBase58()}}]
1897 |     })
1898 | 
1899 |     let stakedNft: any;
1900 | 
1901 | 		for (let index = 0; index < resp.length; index++) {
1902 |       stakedNft = await program.account.soldierData.fetch(resp[index].pubkey);
1903 |       // console.log("test", resp[index].pubkey.toBase58())
1904 |       if(stakedNft.unstaked) continue;
1905 |       const nftMint = new PublicKey(stakedNft.nftMint)
1906 |       let tokenmetaPubkey = await Metadata.getPDA(nftMint);
1907 |       // console.log("test", resp[index].pubkey.toBase58())
1908 |       allnfts.push(tokenmetaPubkey);
1909 |       // console.log("test", resp[index].pubkey.toBase58())
1910 |       stakedNfts.push({data: stakedNft, account: resp[index].pubkey});
1911 | 		}
1912 | 
1913 |     let nftinfo: any[] = [];
1914 |     const buffer = [...allnfts];
1915 |     let count = 100;
1916 |     while(buffer.length > 0) {
1917 |       if(buffer.length < 100) {
1918 |         count = buffer.length;
1919 |       } else {
1920 |         count = 100;
1921 |       }
1922 |       nftinfo = [...nftinfo.concat(await conn.getMultipleAccountsInfo(buffer.splice(0, count)))];
1923 |     }
1924 | 
1925 | 		// const nftinfo: any = await conn.getMultipleAccountsInfo(allnfts);
1926 | 
1927 | 		// let tokenCount = nftinfo.length
1928 | 
1929 | 		for(let i = 0; i < nftinfo.length; i++) {
1930 |       
1931 | 
1932 |       if(nftinfo[i] == null) {
1933 |         continue;
1934 |       }
1935 | 
1936 | 			let metadata : any = new Metadata(owner.toString(), nftinfo[i])
1937 | 
1938 |       // console.log("get data")
1939 | 
1940 |       let data: any;
1941 | 
1942 |       try {
1943 |         data = await axios.get(metadata.data.data.uri, {timeout: axios_timeout});
1944 |       } catch(error) {
1945 |         console.log(error);
1946 |         continue;
1947 |       }
1948 | 
1949 |       // console.log("data loaded", data)
1950 | 
1951 |       if(!data) {
1952 |         // console.log("data error")
1953 |         continue;
1954 |       }
1955 | 
1956 |       const entireData = { ...data.data, id: Number(data.data.name.replace( /^\D+/g, '').split(' - ')[0])}
1957 | 
1958 |       // console.log("data", entireData);
1959 | 
1960 |       let nftMint = new PublicKey(metadata.data.mint)
1961 | 
1962 |       // console.log("account", stakedNfts[i].account.toBase58(), nftMint.toBase58())
1963 | 
1964 |       // verifiednfts.push({account_address : tokenAccounts.value[i].pubkey, mint_address : nftMint, ...entireData})
1965 |       verifiednfts.push({
1966 |         stakeTime : stakedNft.stakeTime.toNumber(),
1967 |         stakeData : stakedNfts[i].account,
1968 |         stakedType : stakedNft.hvhStr,
1969 |         name : entireData.name,
1970 |         // type : entireData.attributes[0].value,
1971 |         ...entireData,
1972 |         ...entireData,
1973 |       })
1974 |     }
1975 | 
1976 |     verifiednfts.sort(function (a: any, b: any) {
1977 |       if (a.name < b.name) { return -1; }
1978 |       if (a.name > b.name) { return 1; }
1979 |       return 0;
1980 |     })
1981 | 
1982 | 		return verifiednfts
1983 | 	}
1984 | 
1985 |   // async function getStakedSoldiersForOwner(
1986 |   //   conn : Connection,
1987 |   //   owner : PublicKey,
1988 |   //   ){
1989 |   //   console.log("+ getStakedNftsForOwner")
1990 |   //   const wallet = new anchor.Wallet(Keypair.generate());
1991 |   //   const provider = new anchor.Provider(conn, wallet, anchor.Provider.defaultOptions());
1992 |   //   const program = new anchor.Program(idl, programId, provider);
1993 |   //   const allTokens: any = []
1994 |   //   let resp = await conn.getProgramAccounts(programId,{
1995 |   //     dataSlice: {length: 0, offset: 0},
1996 |   //     filters: [{dataSize: 8 + SOLDIER_DATA_SIZE},{memcmp:{offset:8,bytes:owner.toBase58()}},{memcmp:{offset:40,bytes:POOL.toBase58()}}]
1997 |   //   })
1998 | 
1999 |   //   for (let index = 0; index < resp.length; index++) {
2000 |   //     try {
2001 |   //       let stakedNft = await program.account.soldierData.fetch(resp[index].pubkey)
2002 |   //       // console.log("test data", stakedNft)
2003 | 
2004 |   //       if(stakedNft.unstaked) continue;
2005 |   //       // let account = await conn.getAccountInfo(stakedNft.nftAccount)
2006 | 
2007 |   //       // let mint = new PublicKey(AccountLayout.decode(account!.data).mint)
2008 |   //       let pda= await getMetadata(stakedNft.nftMint)
2009 |   //       const accountInfo: any = await conn.getParsedAccountInfo(pda);
2010 |   //       let metadata : any = new Metadata(owner.toString(), accountInfo.value);
2011 |   //       const { data }: any = await axios.get(metadata.data.data.uri, {timeout: axios_timeout})
2012 |   //       const entireData = { ...data, id: Number(data.name.replace( /^\D+/g, '').split(' - ')[0])}
2013 |   //       // console.log(entireData);
2014 |   //       allTokens.push({
2015 |   //         stakeTime : stakedNft.stakeTime.toNumber(),
2016 |   //         stakeData : resp[index].pubkey,
2017 |   //         stakedType : stakedNft.hvhStr,
2018 |   //         name : entireData.name,
2019 |   //         // type : entireData.attributes[0].value,
2020 |   //         ...entireData,
2021 |   //       })
2022 | 
2023 |   //       // if(index == resp.length - 1) {
2024 |   //       //   console.log("test")
2025 |   //       //   return allTokens
2026 |   //       // }
2027 |   //     } catch(error) {
2028 |   //       console.log(error)
2029 |   //       continue
2030 |   //     }
2031 |       
2032 |   //   }
2033 |     
2034 |   //   return allTokens
2035 |   // }
2036 | 
2037 |   async function getPoolData(){
2038 |     let wallet = new anchor.Wallet(Keypair.generate())
2039 |     let provider = new anchor.Provider(conn,wallet,confirmOption)
2040 |     const program = new anchor.Program(idl,programId,provider)
2041 | 
2042 |     let poolData = await program.account.pool.fetch(POOL)
2043 | 
2044 |     const unixTime = poolData.startTime.toNumber();
2045 |     const date = new Date(unixTime * 1000);
2046 | 
2047 |     pD = {
2048 |       owner : poolData.owner,
2049 |       souls_mint : poolData.soulsMint,
2050 |       total_souls : poolData.totalSouls.toNumber(),
2051 |       halos_count : poolData.halosCount.toNumber(),
2052 |       horns_count : poolData.hornsCount.toNumber(),
2053 |       soldier_halos_count : poolData.soldierHalosCount.toNumber(),
2054 |       soldier_horns_count : poolData.soldierHornsCount.toNumber(),
2055 |       win_percent : poolData.winPercent.toNumber(),
2056 |       lose_percent : poolData.losePercent.toNumber(),
2057 |       burn_percent : poolData.burnPercent.toNumber(),
2058 |       prev_win : poolData.prevWin,
2059 |       burned : poolData.burned,
2060 |       win_team_stake : poolData.winTeamStake.toNumber(),
2061 |       lost_team_stake : poolData.lostTeamStake.toNumber(),
2062 |       soulAmount : poolData.soulAmount.toNumber(),
2063 |       hvh_percent : poolData.hvhPercent.toNumber(),
2064 |       soldier_percent : poolData.soldierPercent.toNumber(),
2065 |       token_unit : poolData.tokenUnit.toNumber(),
2066 |       staking_period : poolData.stakingPeriod.toNumber(),
2067 |       withdraw_period : poolData.withdrawPeriod.toNumber(),
2068 |       hvh_symbol : poolData.hvhSymbol,
2069 |       soldier_symbol : poolData.soldierSymbol,
2070 |       token_halos : poolData.tokenHalos,
2071 |       token_horns : poolData.tokenHorns,
2072 |       start_time : date.toLocaleString("en-US"),
2073 |       abs_start_time : date.toLocaleString("en-US"),
2074 |       period : poolData.period.toNumber(),
2075 |     }
2076 | 
2077 |     updateStakingPeriod();
2078 |   }
2079 | 
2080 |   const getStakingPeriod = () => {
2081 |     const total_period = pD.staking_period + pD.withdraw_period;
2082 |     const staking_limit = Date.parse(pD.abs_start_time) / 1000 + pD.period * pD.staking_period;
2083 |     const withdraw_limit = Date.parse(pD.abs_start_time) / 1000 + pD.period * total_period;
2084 | 
2085 |     return {total_period, staking_limit, withdraw_limit};
2086 |   }
2087 | 
2088 |   async function getClaimAmount(
2089 |     conn : Connection,
2090 |     owner : PublicKey
2091 |     ){
2092 |       console.log("+ getClaimAmount")
2093 |       const provider = new anchor.Provider(conn, wallet, anchor.Provider.defaultOptions());
2094 |       const program = new anchor.Program(idl, programId, provider);
2095 | 
2096 |       await getPoolData();
2097 | 
2098 |       let claimAmount = 0;
2099 | 
2100 |       const reward_mint : PublicKey = new PublicKey(REWARD_TOKEN);
2101 |       let [stakeState,] = await getProgramAccount(owner, POOL, reward_mint);
2102 |       if((await conn.getAccountInfo(stakeState)) == null) {
2103 |         notify('error', 'Nothing staked!');
2104 |         setClaimAmount(0);
2105 |         // catchFlag = false;
2106 |         return 0;
2107 |       }
2108 | 
2109 |       let stakedinfo = await getStakeStateInfo(stakeState)
2110 | 
2111 |       if(moment().unix() < Date.parse(pD.end_time) / 1000 || moment().unix() > Date.parse(pD.end_withdraw) / 1000) {
2112 |         notify('error', 'Not withdraw period');
2113 |         setClaimAmount(0);
2114 |         // catchFlag = false;
2115 |         return 0;
2116 |       }
2117 | 
2118 |       if(stakedinfo.lastStakeTime.toNumber() < Date.parse(pD.start_time) / 1000) {
2119 |         notify('error', 'You should unstake all tokens and stake again');
2120 |         setClaimAmount(0);
2121 |         // catchFlag = false;
2122 |         return 0;
2123 |       }
2124 | 
2125 |       let total_amount = pD.total_souls;
2126 | 
2127 |       let hvh_amount = total_amount * pD.hvh_percent / 100;
2128 |       let soldier_amount = total_amount * pD.soldier_percent / 100;
2129 |       let burn_amount = total_amount * pD.burn_percent / 100;
2130 | 
2131 |       let claim_amount = 0;
2132 | 
2133 |       let halos_mul = pD.halos_count / 10 | 0;
2134 |       let horns_mul = pD.horns_count / 10 | 0;
2135 | 
2136 |       let total_halos_soldiers = pD.halos_count + (halos_mul + 1) * pD.soldier_halos_count;
2137 |       let total_horns_soldiers = pD.horns_count + pD.soldier_horns_count * (horns_mul + 1);
2138 | 
2139 |       if (total_halos_soldiers > total_horns_soldiers) {
2140 |         if (pD.halos_count != 0) {
2141 |           claim_amount = hvh_amount * pD.win_percent / 100 * stakedinfo.halosCount.toNumber() / pD.halos_count;
2142 |         }
2143 |         if (pD.horns_count != 0) {
2144 |           claim_amount += hvh_amount * pD.lose_percent / 100 * stakedinfo.hornsCount.toNumber() / pD.horns_count;
2145 |         }
2146 |         if (pD.soldier_halos_count != 0) {
2147 |           claim_amount += soldier_amount * pD.win_percent  / 100 * stakedinfo.soldierHalosCount.toNumber() / pD.soldier_halos_count;
2148 |         }
2149 |         if (pD.soldier_horns_count != 0) {
2150 |           claim_amount += soldier_amount * pD.lose_percent / 100 * stakedinfo.soldierHornsCount.toNumber() / pD.soldier_horns_count;
2151 |         }
2152 |     } else if (total_halos_soldiers < total_horns_soldiers) {
2153 |         if (pD.halos_count != 0) {
2154 |           claim_amount = hvh_amount * pD.lose_percent / 100 * stakedinfo.halosCount.toNumber() / pD.halos_count;
2155 |         }
2156 |         if (pD.horns_count != 0) {
2157 |           claim_amount += hvh_amount * pD.win_percent / 100 * stakedinfo.hornsCount.toNumber() / pD.horns_count;
2158 |         }
2159 |         if (pD.soldier_halos_count != 0) {
2160 |           claim_amount += soldier_amount * pD.lose_percent / 100 * stakedinfo.soldierHalosCount.toNumber() / pD.soldier_halos_count;
2161 |         }
2162 |         if (pD.soldier_horns_count != 0) {
2163 |           claim_amount += soldier_amount * pD.win_percent / 100 * stakedinfo.soldierHornsCount.toNumber() / pD.soldier_horns_count;
2164 |         }
2165 |     } else {
2166 |           claim_amount = (stakedinfo.halosCount.toNumber() + stakedinfo.hornsCount.toNumber()) * pD.soulAmount * pD.token_unit;
2167 |         if (pD.prev_win == 0) {
2168 |           claim_amount += (stakedinfo.soldierHalosCount.toNumber() * pD.win_team_stake + stakedinfo.soldierHornsCount.toNumber() * pD.lost_team_stake) * pD.token_unit;
2169 |         } else if (pD.prev_win == 1) {
2170 |           claim_amount += (stakedinfo.soldierHalosCount.toNumber() * pD.lost_team_stake + stakedinfo.soldierHornsCount.toNumber() * pD.win_team_stake) * pD.token_unit;
2171 |         } else {
2172 |           claim_amount = (stakedinfo.soldierHalosCount.toNumber() + stakedinfo.soldierHornsCount.toNumber()) * pD.soulAmount * pD.token_unit;
2173 |         }
2174 |     }
2175 | 
2176 | 
2177 |     claimAmount = claim_amount / pD.token_unit;
2178 | 
2179 |     if(stakedinfo.claimed)
2180 |       claimAmount = 0;
2181 | 
2182 |     setClaimAmount(claimAmount);
2183 |   }
2184 | 
2185 |   let sendTransaction = async function sendTransaction(transaction : Transaction,signers : Keypair[]) {
2186 |     try{
2187 |       transaction.feePayer = wallet.publicKey
2188 |       transaction.recentBlockhash = (await conn.getRecentBlockhash('max')).blockhash;
2189 |       // await transaction.setSigners(wallet.publicKey,...signers.map(s => s.publicKey));
2190 |       // if(signers.length != 0)
2191 |       //   await transaction.partialSign(...signers)
2192 |       const signedTransaction = await wallet.signTransaction(transaction);
2193 |       let hash = await conn.sendRawTransaction(await signedTransaction.serialize());
2194 |       await conn.confirmTransaction(hash);
2195 |       // await getNfts();
2196 |       // setLoading(false);
2197 |       notify('success', 'Success!');
2198 |       return true;
2199 |     } catch(err) {
2200 |       console.log(err)
2201 |       // await getNfts()
2202 |       notify('error', 'Failed Instruction!');
2203 |       setLoading(false);
2204 |     }
2205 |   }
2206 | 
2207 |   async function getNfts(){
2208 |     // setLoading(true);
2209 |     nfts.splice(0,nfts.length)
2210 |     stakedNfts.splice(0,stakedNfts.length)
2211 |     soldiers.slice(0, soldiers.length)
2212 |     stakedNfts.slice(0, stakedNfts.length)
2213 |     stakedSoldiers.slice(0, stakedSoldiers.length)
2214 |     notify('info', 'Loading Info!');
2215 |     await getPoolData()
2216 |     await getOwnerStakeStateInfo();
2217 |     notify('info', 'Loading HvH!');
2218 |     nfts = await getNftsForOwner(conn,wallet.publicKey)
2219 |     // notify('success', 'HvH Loaded!');
2220 |     notify('info', 'Loading Staked HvH!');
2221 |     stakedNfts = await getStakedNftsForOwner(conn,wallet.publicKey)
2222 |     // notify('success', 'Staked HvH Loaded!');
2223 |     notify('info', 'Loading Souldiers!');
2224 |     soldiers = await getSoldiersForOwner(conn, wallet.publicKey)
2225 |     // notify('success', 'Soldiers Loaded!');
2226 |     notify('info', 'Loading Staked Souldiers!');
2227 |     stakedSoldiers = await getStakedSoldiersForOwner(conn, wallet.publicKey)
2228 |     // notify('success', 'Staked Soldiers Loaded!');
2229 |     notify('info', 'Succesfully Loaded All!');
2230 |     // console.log(nfts, stakedNfts)
2231 |     // setLoading(false);
2232 |   }
2233 | 
2234 | 	return <div className="row">
2235 |     <Loading className={loading ? "" : "loading_disable"} />
2236 |     <div className='row empty-div'>
2237 |     </div>
2238 |     <div className='row vs-label'>
2239 |       <img src="https://glittercloudsolutions.com/wp-content/uploads/2022/03/61cb5aeb6c8c4a74f25dfb6d_Asset-3@3x-1024x93.png" sizes="100vw" alt="" loading="lazy"/>
2240 |     </div>  
2241 |     <div className='row vs-video'>
2242 |       {!catchFlag && <img src="https://glittercloudsolutions.com/wp-content/uploads/2022/03/61cc0814446fd66fedd66325_video-4-metro-1920x1080-1-1536x864.gif" alt="" loading="lazy" />}
2243 |       { catchFlag && <div className="row">
2244 |         <div className='row'>
2245 |         { fightingFlag === 0 && <div className="winning-video" dangerouslySetInnerHTML={{ __html: `
2246 |             <video
2247 |               loop
2248 |               muted
2249 |               autoplay
2250 |               playsinline
2251 |               src="${winhalos}"
2252 |               class="video-style"
2253 |             />,
2254 |           ` }}></div>
2255 |           }
2256 |           { fightingFlag === 1 && <div className="winning-video" dangerouslySetInnerHTML={{ __html: `
2257 |             <video
2258 |               loop
2259 |               muted
2260 |               autoplay
2261 |               playsinline
2262 |               src="${winhorns}"
2263 |               class="video-style"
2264 |             />,
2265 |           ` }}></div>
2266 |           }
2267 |         </div>
2268 |         <div className="row winteam-label">
2269 |           { (fightingFlag === 0 || fightingFlag === 1 ) && <p>The {winTeam} Are Victorious!</p> }
2270 |           { fightingFlag === 2 && <p>The Match Was a Draw!</p> }
2271 |           <p>Claimable Amount: {claimableAmount}</p>
2272 |         </div>
2273 |       </div>
2274 |     }
2275 |     </div> 
2276 |     {pD && 
2277 |       <div className='row'>
2278 |         <div className='row'>
2279 |           <div className='col-lg-6 col-12 time-show'>
2280 |             <p>Staking Period:</p>
2281 |             <p>{stakingPeriod.start} - {stakingPeriod.end}</p>
2282 |           </div>
2283 |           <div className='col-lg-6 col-12 time-show'>
2284 |             <p>Withdraw Period:</p>
2285 |             <p>{withdrawPeriod.start} - {withdrawPeriod.end}</p>
2286 |           </div>
2287 |         </div>
2288 |       </div>
2289 |     }
2290 |     <div className='row'>
2291 |       <div className='row platform-label'>
2292 |         <p>STAKING PLATFORM</p>
2293 |       </div>
2294 |       <div className='row action-all-div'>
2295 |         <div className='col-12 col-md-6 col-lg-6 col-xl-6 action-div'>
2296 |           <button className="action-button" onClick={async () =>{await stakeAll(true)}}>StakeHalos</button>
2297 |         </div>
2298 |         <div className='col-12 col-md-6 col-lg-6 col-xl-6 action-div'>
2299 |           <button className="action-button" onClick={async () =>{await stakeAll(false)}}>StakeHorns</button>
2300 |         </div>
2301 |         <div className='col-12 col-md-6 col-lg-6 col-xl-6 action-div'>
2302 |           <button className="action-button" onClick={async () =>{await setSelectAllFlag()}}>Stake Soldiers</button>
2303 |         </div>
2304 |         <div className='col-12 col-md-6 col-lg-6 col-xl-6 action-div'>
2305 |           <button className="action-button" onClick={async () =>{await unstakeSoldiersAll()}}>Unstake Soldiers</button>
2306 |         </div>
2307 |         <div className='col-12 col-md-6 col-lg-6 col-xl-6 action-div'>
2308 |           <button className="action-button" onClick={async () =>{await claim()}}>Claim</button>
2309 |         </div>
2310 |         <div className='col-12 col-md-6 col-lg-6 col-xl-6 action-div'>
2311 |           <button className="action-button" onClick={async () =>{await unstakeAll()}}>Unstake HvH</button>
2312 |         </div>
2313 |       </div>
2314 |     </div>
2315 |     <div className='row'>
2316 |       <div className='col-12 col-md-6 col-lg-6 col-xl-6'>
2317 |         <div className='row nft-div'>
2318 |           <p>YOUR WALLET NFT</p>
2319 |         </div>
2320 |         <div className='row'>
2321 |           {
2322 |             nfts.length && <div className="row">
2323 |             {
2324 |               nfts.map((nft,idx)=>{
2325 |                 return <div className="w3-card-4 w3-dark-grey col-6 col-md-4 col-lg-4 col-xl-4" key={idx}>
2326 |                   <div className="w3-container w3-center">
2327 |                     <h3>{nft.name}</h3>
2328 |                       <img className="card-img-top" src={nft.image} alt="Image Error"/>
2329 |                     <h5>{nft.attributes[0].value}</h5>
2330 |                     <div className="w3-section">
2331 |                       <button className="w3-button w3-green" onClick={async ()=>{
2332 |                           await stake(nft.account_address, nft.mint_address, nft.attributes[0].value)
2333 |                         }}>Stake</button>
2334 |                     </div>
2335 |                   </div>
2336 |                 </div>
2337 |               })
2338 |             }
2339 |             </div>
2340 |           }
2341 |         </div>
2342 |       </div>
2343 |       <div className='col-12 col-md-6 col-lg-6 col-xl-6'>
2344 |         <div className='row nft-div'>
2345 |           <p>YOUR STAKED NFT</p>
2346 |         </div>
2347 |         <div className='row'>
2348 |           {
2349 |             stakedNfts.map((nft,idx)=>{
2350 |               return <div className="w3-card-4 w3-dark-grey col-6 col-md-4 col-lg-4 col-xl-4" key={idx}>
2351 |               <div className="w3-container w3-center">
2352 |                 <h3>{nft.name}</h3>
2353 |                   <img className="card-img-top" src={nft.image} alt="Image Error"/>
2354 |                 <h5>{nft.type}</h5>
2355 |                 <h5>{(new Date(nft.stakeTime * 1000)).toLocaleString("en-US")}</h5>
2356 |                 <div className="w3-section">
2357 |                   <button className="w3-button w3-green" onClick={async ()=>{
2358 |                       await unstake(nft.stakeData, nft.attributes[0].value);
2359 |                     }}>UnStake</button>
2360 |                 </div>
2361 |               </div>
2362 |             </div>
2363 |             })
2364 |           }
2365 |         </div>
2366 |       </div>
2367 |     </div>
2368 | 
2369 |     <div className='row'>
2370 |       <div className='col-12 col-md-6 col-lg-6 col-xl-6'>
2371 |         <div className='row nft-div'>
2372 |           <p>YOUR WALLET SOULDIERS</p>
2373 |         </div>
2374 |         <div className='row'>
2375 |           {
2376 |             soldiers.length && <div className="row">
2377 |             {
2378 |               soldiers.map((nft,idx)=>{
2379 |                 return <div className="w3-card-4 w3-dark-grey col-6 col-md-4 col-lg-4 col-xl-4" key={idx}>
2380 |                   <div className="w3-container w3-center">
2381 |                     <h3>{nft.name}</h3>
2382 |                       <img className="card-img-top" src={nft.image} alt="Image Error"/>
2383 |                     {/* <h5>{nft.attributes[0].value}</h5> */}
2384 |                     <div className="w3-section">
2385 |                       <button className="w3-button w3-green" onClick={async ()=>{
2386 |                           setSelectSoldier(nft.account_address, nft.mint_address)
2387 |                           // await stake(nft.account_address, nft.mint_address, nft.attributes[0].value)
2388 |                         }}>Stake</button>
2389 |                     </div>
2390 |                   </div>
2391 |                 </div>
2392 |               })
2393 |             }
2394 |             </div>
2395 |           }
2396 |         </div>
2397 |       </div>
2398 |       <div className='col-12 col-md-6 col-lg-6 col-xl-6'>
2399 |         <div className='row nft-div'>
2400 |           <p>YOUR STAKED SOULDIERS</p>
2401 |         </div>
2402 |         <div className='row'>
2403 |           {
2404 |             stakedSoldiers.map((nft,idx)=>{
2405 |               return <div className="w3-card-4 w3-dark-grey col-6 col-md-4 col-lg-4 col-xl-4" key={idx}>
2406 |               <div className="w3-container w3-center">
2407 |                 <h3>{nft.name}</h3>
2408 |                   <img className="card-img-top" src={nft.image} alt="Image Error"/>
2409 |                 <h5>{nft.stakedType}</h5>
2410 |                 <h5>{(new Date(nft.stakeTime * 1000)).toLocaleString("en-US")}</h5>
2411 |                 <div className="w3-section">
2412 |                   <button className="w3-button w3-green" onClick={async ()=>{
2413 |                       await unstakesoldier(nft.stakeData, nft.attributes[0].value);
2414 |                     }}>UnStake</button>
2415 |                 </div>
2416 |               </div>
2417 |             </div>
2418 |             })
2419 |           }
2420 |         </div>
2421 |       </div>
2422 |     </div>
2423 |     
2424 |     <div className='row warning-label'>
2425 |       <p>
2426 |       YOU MUST UNSTAKE YOUR HORNS AND HALOS EACH WEEK AND RESTAKE THEM DURING THE STAKING PERIOD.
2427 |       </p>
2428 |       <p>
2429 |       YOU WILL NOT PARTICIPATE IN COMPETITIVE STAKING IF YOU LEAVE YOUR NFTs STAKED.
2430 |       </p>
2431 |     </div>
2432 |     { ownerstakedinfo && <div className='row state-div'>
2433 |         {/* <h3>Your Staking State</h3> */}
2434 |         <table className="table table-hover state-table">
2435 |           <thead>
2436 |             <tr>
2437 |               <th scope="col">State</th>
2438 |               <th scope="col">Amount</th>
2439 |             </tr>
2440 |           </thead>
2441 |           <tbody>
2442 |             <tr>
2443 |               <th scope="row">Staked Halos Unit</th>
2444 |               <td>{ownerstakedinfo.halos_unit}</td>
2445 |             </tr>
2446 |             <tr>
2447 |               <th scope="row">Staked Horns Unit</th>
2448 |               <td>{ownerstakedinfo.horns_unit}</td>
2449 |             </tr>
2450 |             <tr>
2451 |               <th scope="row">Souls in wallet</th>
2452 |               <td>{ownerstakedinfo.souls}</td>
2453 |             </tr>
2454 |           </tbody>
2455 |         </table>
2456 |       </div>
2457 |     }
2458 |     <div className='row nft-collection-div'>
2459 |       <img src="https://glittercloudsolutions.com/wp-content/uploads/2022/03/61cc058db2a9f7c13ce75b20_web-rotate-devil-300x300.gif" alt="" loading="lazy" />
2460 |       <img src="https://glittercloudsolutions.com/wp-content/uploads/2022/03/61cc0557d84fe982e9aaf019_web-rotate-angel-300x300.gif" alt="" loading="lazy" />
2461 |     </div>
2462 |     <div className='row community-label'>
2463 |       <p>
2464 |         JOIN THE COMMUNITY
2465 |       </p>
2466 |     </div>
2467 |     <div className='row community-icon'>
2468 |       <a href="#" ><FaDiscord style={{width:"50px", height:"40px", color:"white"}}/></a>
2469 |       <a href="#" ><FaTwitter style={{width:"50px", height:"40px", color:"white"}}/></a>
2470 |     </div>
2471 |     {/* <Button variant="primary" onClick={() => setModalShow(true)}>
2472 |       Launch vertically centered modal
2473 |     </Button> */}
2474 | 
2475 |     <SelectHHModal
2476 |       show={modalShow}
2477 |       OnHalos={() => stakeSoldierToHalos()}
2478 |       OnHorns={() => stakeSoldierToHorns()}
2479 |       onHide={() => setModalShow(false)}
2480 |     />
2481 | 
2482 |     {/* <div className='row'>
2483 |       <div className='cur-time-show'>
2484 |         <p>Today: {todaystr}</p>
2485 |       </div>
2486 |     </div>
2487 |     <hr />
2488 |     <div className='row warning-label'>
2489 |       <p>
2490 |       YOU MUST UNSTAKE YOUR HORNS AND HALOS EACH WEEK AND RESTAKE THEM DURING THE STAKING PERIOD.
2491 |       </p>
2492 |       <p>
2493 |       YOU WILL NOT PARTICIPATE IN COMPETITIVE STAKING IF YOU LEAVE YOUR NFTs STAKED.
2494 |       </p>
2495 |     </div>
2496 |     <hr />
2497 |     {pD && 
2498 |       <div className='row'>
2499 |         <div className='row'>
2500 |           <div className='col-lg-6 col-12 time-show'>
2501 |             <p>Staking Period:</p>
2502 |             <p>{stakingPeriod.start} - {stakingPeriod.end}</p>
2503 |           </div>
2504 |           <div className='col-lg-6 col-12 time-show'>
2505 |             <p>Withdraw Period:</p>
2506 |             <p>{withdrawPeriod.start} - {withdrawPeriod.end}</p>
2507 |           </div>
2508 |         </div>
2509 |       </div>
2510 |     }
2511 |    	<hr/>
2512 |     { catchFlag && <div className="row">
2513 |         <div className='row' style={{display:"flex", justifyContent:"center"}}>
2514 |           <div className="winteam-label">
2515 |             { (fightingFlag === 0 || fightingFlag === 1 ) && <p>The {winTeam} Are Victorious!</p> }
2516 |             { fightingFlag === 2 && <p>The Match Was a Draw!</p> }
2517 |           </div>
2518 |         </div>
2519 | 
2520 |         <div className='row'>
2521 |         { fightingFlag === 0 && <div className="winning-video" dangerouslySetInnerHTML={{ __html: `
2522 |             <video
2523 |               loop
2524 |               muted
2525 |               autoplay
2526 |               playsinline
2527 |               src="${winhalos}"
2528 |               class="video-style"
2529 |             />,
2530 |           ` }}></div>
2531 |           }
2532 |           { fightingFlag === 1 && <div className="winning-video" dangerouslySetInnerHTML={{ __html: `
2533 |             <video
2534 |               loop
2535 |               muted
2536 |               autoplay
2537 |               playsinline
2538 |               src="${winhorns}"
2539 |               class="video-style"
2540 |             />,
2541 |           ` }}></div>
2542 |           }
2543 |         </div>
2544 |         <div className='row' style={{display:"flex", justifyContent:"center"}}>
2545 |             <div className="claim-label" >
2546 |               <p>Your Claimable Amount: {claimableAmount}</p>
2547 |             </div>
2548 |             <div style={{ width: "20%" }}>
2549 |               <button className="button custom-btn" onClick={async () =>{await claim()}}><span>Claim</span></button>
2550 |             </div>
2551 |         </div>
2552 |       </div>
2553 |     }
2554 |     <hr/>
2555 |     { pD && <div className='row'>
2556 |         <h3>Pool State</h3>
2557 |           <table className="table table-hover ">
2558 |           <thead>
2559 |             <tr>
2560 |               <th scope="col">State</th>
2561 |               <th scope="col">Amount</th>
2562 |             </tr>
2563 |           </thead>
2564 |           <tbody>
2565 |             <tr>
2566 |               <th scope="row">Staked souls</th>
2567 |               <td>{pD.total_souls / pD.token_unit}</td>
2568 |             </tr>
2569 |           </tbody>
2570 |           <tbody>
2571 |             <tr>
2572 |               <th scope="row">Souls per NFT</th>
2573 |               <td>{pD.soulAmount}</td>
2574 |             </tr>
2575 |           </tbody>
2576 |           <tbody>
2577 |             <tr>
2578 |               <th scope="row">Staked Halos</th>
2579 |               <td>{pD.halos_count}</td>
2580 |             </tr>
2581 |           </tbody>
2582 |           <tbody>
2583 |             <tr>
2584 |               <th scope="row">Staked Horns</th>
2585 |               <td>{pD.horns_count}</td>
2586 |             </tr>
2587 |           </tbody>
2588 |           <tbody>
2589 |             <tr>
2590 |               <th scope="row">Winning</th>
2591 |               <td>{pD.win_percent}%</td>
2592 |             </tr>
2593 |           </tbody>
2594 |           <tbody>
2595 |             <tr>
2596 |               <th scope="row">Fail</th>
2597 |               <td>{pD.lose_percent}%</td>
2598 |             </tr>
2599 |           </tbody>
2600 |           <tbody>
2601 |             <tr>
2602 |               <th scope="row">Burn</th>
2603 |               <td>{pD.burn_percent}%</td>
2604 |             </tr>
2605 |           </tbody>
2606 |         </table>
2607 |       </div>
2608 |     }
2609 |     <hr />
2610 |     { ownerstakedinfo && <div className='row'>
2611 |         <h3>Your Staking State</h3>
2612 |         <table className="table table-hover">
2613 |           <thead>
2614 |             <tr>
2615 |               <th scope="col">State</th>
2616 |               <th scope="col">Amount</th>
2617 |             </tr>
2618 |           </thead>
2619 |           <tbody>
2620 |             <tr>
2621 |               <th scope="row">Staked Halos</th>
2622 |               <td>{ownerstakedinfo.halosCount.toNumber()}</td>
2623 |             </tr>
2624 |             <tr>
2625 |               <th scope="row">Staked Horns</th>
2626 |               <td>{ownerstakedinfo.hornsCount.toNumber()}</td>
2627 |             </tr>
2628 |             <tr>
2629 |               <th scope="row">Souls in wallet</th>
2630 |               <td>{ownerstakedinfo.souls}</td>
2631 |             </tr>
2632 |           </tbody>
2633 |         </table>
2634 |       </div>
2635 |     }
2636 |     <hr />
2637 | 		<div className="row">
2638 | 			<div className="col-lg-6">
2639 |         <div className='row'>
2640 |           <div className='row'>
2641 |             <div className='col-6 col-md-6 col-lg-6 col-xl-6'>
2642 |               <h4>Your Wallet NFT</h4>
2643 |             </div>
2644 |             <div className='col-6 col-md-6 col-lg-6 col-xl-6'>
2645 |               <button type="button" className="stake_button" style={{float:"right"}} onClick={async () =>{
2646 |                 await stakeAll(true)
2647 |               }}><span>StakeHalos</span></button>
2648 |               <button type="button" className="stake_button" style={{float:"right"}} onClick={async () =>{
2649 |                 await stakeAll(false)
2650 |               }}><span>StakeHorns</span></button>
2651 |             </div>
2652 |           </div>
2653 |           <div className='row'>
2654 |             {nfts.length && <div className="row">
2655 |               {
2656 |                 nfts.map((nft,idx)=>{
2657 |                   // console.log(nft);
2658 |                   return <div className="w3-card-4 w3-dark-grey col-6 col-md-4 col-lg-4 col-xl-4" key={idx}>
2659 |                   <div className="w3-container w3-center">
2660 |                     <h3>{nft.name}</h3>
2661 |                       <img className="card-img-top" src={nft.image} alt="Image Error"/>
2662 |                     <h5>{nft.attributes[0].value}</h5>
2663 |                     <div className="w3-section">
2664 |                       <button className="w3-button w3-green" onClick={async ()=>{
2665 |                           await stake(nft.account_address, nft.mint_address, nft.attributes[0].value)
2666 |                         }}>Stake</button>
2667 |                     </div>
2668 |                   </div>
2669 |                 </div>
2670 |                 })
2671 |               }
2672 |             </div>
2673 | }
2674 |           </div>
2675 | 				</div>
2676 | 			</div>
2677 |       <div className="col-lg-6">
2678 |         <div className='row'>
2679 |           <div className='row'>
2680 |             <div className='col-6 col-md-6 col-lg-6 col-xl-6'>
2681 |               <h4>Your Staked NFT</h4>
2682 |             </div>
2683 |             <div className='col-6 col-md-6 col-lg-6 col-xl-6'>
2684 |               <button type="button" className="unstake_button" style={{float:"right"}} onClick={async () =>{
2685 |                 await unstakeAll()
2686 |               }}><span>UnStakeAll</span></button>
2687 |             </div>
2688 |           </div>
2689 |         </div>
2690 |         <div className='row'>
2691 |           <div className="row">
2692 |           {
2693 |             stakedNfts.map((nft,idx)=>{
2694 |               return <div className="w3-card-4 w3-dark-grey col-6 col-md-4 col-lg-4 col-xl-4" key={idx}>
2695 |               <div className="w3-container w3-center">
2696 |                 <h3>{nft.name}</h3>
2697 |                   <img className="card-img-top" src={nft.image} alt="Image Error"/>
2698 |                 <h5>{nft.type}</h5>
2699 |                 <h5>{(new Date(nft.stakeTime * 1000)).toLocaleString("en-US")}</h5>
2700 |                 <div className="w3-section">
2701 |                   <button className="w3-button w3-green" onClick={async ()=>{
2702 |                       await unstake(nft.stakeData, nft.attributes[0].value);
2703 |                     }}>UnStake</button>
2704 |                 </div>
2705 |               </div>
2706 |             </div>
2707 |             })
2708 |           }
2709 |           </div>
2710 |         </div>
2711 |       </div>
2712 | 		</div>
2713 |     <hr/> */}
2714 | 	</div>
2715 | }


--------------------------------------------------------------------------------