From b79a21df8ee321af20fde3efc2a1d35fc6e8a63d Mon Sep 17 00:00:00 2001 From: LinXJ1204 <39145342+LinXJ1204@users.noreply.github.com> Date: Fri, 15 Sep 2023 09:09:43 +0800 Subject: [PATCH] feat: frontend_arch --- apps/backend/package-lock.json | 450 ++++++++++++++++++ apps/backend/package.json | 4 +- apps/backend/server.js | 40 +- apps/backend/src/TON/add_ton_sale.js | 83 ++++ apps/backend/src/TON/search_ton_asset.js | 17 + .../src/TON/src/contracts/NftCollection.js | 126 +++++ apps/backend/src/TON/src/contracts/NftItem.js | 86 ++++ .../src/TON/src/contracts/NftMarketplace.js | 58 +++ apps/backend/src/TON/src/contracts/Sales.js | 124 +++++ apps/backend/src/TON/src/delay.js | 12 + apps/backend/src/TON/src/metadata.js | 31 ++ apps/backend/src/TON/src/utils.js | 71 +++ apps/backend/src/co2storage/search.js | 72 ++- apps/backend/undefined.json | 2 +- apps/ton-web/components/buyerTable.tsx | 78 +-- apps/ton-web/components/buyerTableItem.tsx | 31 +- apps/ton-web/components/navbar.tsx | 12 +- apps/ton-web/components/provideButton.tsx | 18 +- apps/ton-web/components/sellerTable.tsx | 35 +- apps/ton-web/pages/_app.tsx | 17 +- apps/ton-web/pages/buyer.tsx | 50 +- apps/ton-web/pages/index.tsx | 2 +- apps/ton-web/pages/seller.tsx | 19 +- apps/ton-web/photo/82877075.jpg | Bin 0 -> 385173 bytes apps/ton-web/service/api.ts | 18 +- apps/ton-web/service/{client.ts => client.js} | 2 +- apps/ton-web/service/contract.ts | 149 ------ apps/ton-web/service/market.js | 33 ++ apps/ton-web/styles/globals.css | 45 +- apps/ton-web/tsconfig.json | 2 +- apps/ton-web/type.ts | 11 + pnpm-lock.yaml | 74 +++ 32 files changed, 1474 insertions(+), 298 deletions(-) create mode 100644 apps/backend/package-lock.json create mode 100644 apps/backend/src/TON/add_ton_sale.js create mode 100644 apps/backend/src/TON/search_ton_asset.js create mode 100644 apps/backend/src/TON/src/contracts/NftCollection.js create mode 100644 apps/backend/src/TON/src/contracts/NftItem.js create mode 100644 apps/backend/src/TON/src/contracts/NftMarketplace.js create mode 100644 apps/backend/src/TON/src/contracts/Sales.js create mode 100644 apps/backend/src/TON/src/delay.js create mode 100644 apps/backend/src/TON/src/metadata.js create mode 100644 apps/backend/src/TON/src/utils.js create mode 100644 apps/ton-web/photo/82877075.jpg rename apps/ton-web/service/{client.ts => client.js} (88%) delete mode 100644 apps/ton-web/service/contract.ts create mode 100644 apps/ton-web/service/market.js diff --git a/apps/backend/package-lock.json b/apps/backend/package-lock.json new file mode 100644 index 0000000..2b05811 --- /dev/null +++ b/apps/backend/package-lock.json @@ -0,0 +1,450 @@ +{ + "name": "hackathon-backend", + "version": "0.0.1", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "hackathon-backend", + "version": "0.0.1", + "dependencies": { + "@co2-storage/js-api": "^1.4.0", + "@ipld/dag-pb": "^4.0.4", + "body-parser": "^1.20.2", + "cors": "^2.8.5", + "ethers": "^5.7.2", + "express": "^4.18.2", + "fs": "^0.0.1-security", + "ipfs-unixfs": "^11.0.1", + "multiformats": "^12.0.1", + "path": "^0.12.7", + "ton": "^13.6.1", + "ton-crypto": "^3.2.0" + }, + "devDependencies": { + "env-cmd": "^10.1.0" + } + }, + "../../node_modules/.pnpm/@co2-storage+js-api@1.4.0/node_modules/@co2-storage/js-api": { + "version": "1.4.0", + "license": "MIT", + "dependencies": { + "@ipld/dag-pb": "^4.0.4", + "@libp2p/websockets": "^6.0.3", + "@metamask/eth-sig-util": "^5.1.0", + "@multiformats/multiaddr": "^12.1.3", + "axios": "^1.4.0", + "browser-or-node": "^2.1.1", + "filereader": "^0.10.3", + "ipfs-http-client": "^60.0.0", + "ipfs-unixfs": "^11.0.1", + "multiformats": "^12.0.1", + "multihashes": "^4.0.3", + "web3": "^4.0.1", + "ws": "^8.13.0" + } + }, + "../../node_modules/.pnpm/@ipld+dag-pb@4.0.4/node_modules/@ipld/dag-pb": { + "version": "4.0.4", + "license": "Apache-2.0 OR MIT", + "dependencies": { + "multiformats": "^12.0.1" + }, + "devDependencies": { + "aegir": "^39.0.5" + }, + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + } + }, + "../../node_modules/.pnpm/body-parser@1.20.2/node_modules/body-parser": { + "version": "1.20.2", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.11.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "devDependencies": { + "eslint": "8.34.0", + "eslint-config-standard": "14.1.1", + "eslint-plugin-import": "2.27.5", + "eslint-plugin-markdown": "3.0.0", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "6.1.1", + "eslint-plugin-standard": "4.1.0", + "methods": "1.1.2", + "mocha": "10.2.0", + "nyc": "15.1.0", + "safe-buffer": "5.2.1", + "supertest": "6.3.3" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "../../node_modules/.pnpm/cors@2.8.5/node_modules/cors": { + "version": "2.8.5", + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "devDependencies": { + "after": "0.8.2", + "eslint": "2.13.1", + "express": "4.16.3", + "mocha": "5.2.0", + "nyc": "13.1.0", + "supertest": "3.3.0" + }, + "engines": { + "node": ">= 0.10" + } + }, + "../../node_modules/.pnpm/env-cmd@10.1.0/node_modules/env-cmd": { + "version": "10.1.0", + "dev": true, + "license": "MIT", + "dependencies": { + "commander": "^4.0.0", + "cross-spawn": "^7.0.0" + }, + "bin": { + "env-cmd": "bin/env-cmd.js" + }, + "devDependencies": { + "@types/chai": "^4.0.0", + "@types/cross-spawn": "^6.0.0", + "@types/mocha": "^7.0.0", + "@types/node": "^12.0.0", + "@types/sinon": "^7.0.0", + "chai": "^4.0.0", + "coveralls": "^3.0.0", + "mocha": "^7.0.0", + "nyc": "^15.0.0", + "sinon": "^8.0.0", + "ts-node": "^8.0.0", + "ts-standard": "^4.0.0", + "typescript": "^3.7.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "../../node_modules/.pnpm/ethers@5.7.2/node_modules/ethers": { + "version": "5.7.2", + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@ethersproject/abi": "5.7.0", + "@ethersproject/abstract-provider": "5.7.0", + "@ethersproject/abstract-signer": "5.7.0", + "@ethersproject/address": "5.7.0", + "@ethersproject/base64": "5.7.0", + "@ethersproject/basex": "5.7.0", + "@ethersproject/bignumber": "5.7.0", + "@ethersproject/bytes": "5.7.0", + "@ethersproject/constants": "5.7.0", + "@ethersproject/contracts": "5.7.0", + "@ethersproject/hash": "5.7.0", + "@ethersproject/hdnode": "5.7.0", + "@ethersproject/json-wallets": "5.7.0", + "@ethersproject/keccak256": "5.7.0", + "@ethersproject/logger": "5.7.0", + "@ethersproject/networks": "5.7.1", + "@ethersproject/pbkdf2": "5.7.0", + "@ethersproject/properties": "5.7.0", + "@ethersproject/providers": "5.7.2", + "@ethersproject/random": "5.7.0", + "@ethersproject/rlp": "5.7.0", + "@ethersproject/sha2": "5.7.0", + "@ethersproject/signing-key": "5.7.0", + "@ethersproject/solidity": "5.7.0", + "@ethersproject/strings": "5.7.0", + "@ethersproject/transactions": "5.7.0", + "@ethersproject/units": "5.7.0", + "@ethersproject/wallet": "5.7.0", + "@ethersproject/web": "5.7.1", + "@ethersproject/wordlists": "5.7.0" + } + }, + "../../node_modules/.pnpm/express@4.18.2/node_modules/express": { + "version": "4.18.2", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.1", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.5.0", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.2.0", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.1", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.7", + "proxy-addr": "~2.0.7", + "qs": "6.11.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.18.0", + "serve-static": "1.15.0", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "devDependencies": { + "after": "0.8.2", + "connect-redis": "3.4.2", + "cookie-parser": "1.4.6", + "cookie-session": "2.0.0", + "ejs": "3.1.8", + "eslint": "8.24.0", + "express-session": "1.17.2", + "hbs": "4.2.0", + "marked": "0.7.0", + "method-override": "3.0.0", + "mocha": "10.0.0", + "morgan": "1.10.0", + "multiparty": "4.2.3", + "nyc": "15.1.0", + "pbkdf2-password": "1.2.1", + "supertest": "6.3.0", + "vhost": "~3.0.2" + }, + "engines": { + "node": ">= 0.10.0" + } + }, + "../../node_modules/.pnpm/fs@0.0.1-security/node_modules/fs": { + "version": "0.0.1-security", + "license": "ISC" + }, + "../../node_modules/.pnpm/ipfs-unixfs@11.0.1/node_modules/ipfs-unixfs": { + "version": "11.0.1", + "license": "Apache-2.0 OR MIT", + "dependencies": { + "err-code": "^3.0.1", + "protons-runtime": "^5.0.0", + "uint8arraylist": "^2.4.3" + }, + "devDependencies": { + "aegir": "^39.0.6", + "protons": "^7.0.2", + "uint8arrays": "^4.0.2" + }, + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + } + }, + "../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats": { + "version": "12.0.1", + "license": "Apache-2.0 OR MIT", + "devDependencies": { + "@stablelib/sha256": "^1.0.1", + "@stablelib/sha512": "^1.0.1", + "@types/node": "^20.3.1", + "aegir": "^37.7.5", + "buffer": "^6.0.3", + "cids": "^1.1.9" + }, + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + } + }, + "../../node_modules/.pnpm/path@0.12.7/node_modules/path": { + "version": "0.12.7", + "license": "MIT", + "dependencies": { + "process": "^0.11.1", + "util": "^0.10.3" + } + }, + "node_modules/@co2-storage/js-api": { + "resolved": "../../node_modules/.pnpm/@co2-storage+js-api@1.4.0/node_modules/@co2-storage/js-api", + "link": true + }, + "node_modules/@ipld/dag-pb": { + "resolved": "../../node_modules/.pnpm/@ipld+dag-pb@4.0.4/node_modules/@ipld/dag-pb", + "link": true + }, + "node_modules/axios": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/axios/-/axios-0.25.0.tgz", + "integrity": "sha512-cD8FOb0tRH3uuEe6+evtAbgJtfxr7ly3fQjYcMcuPlgkwVS9xboaVIpcDV+cYQe+yGykgwZCs1pzjntcGa6l5g==", + "dependencies": { + "follow-redirects": "^1.14.7" + } + }, + "node_modules/body-parser": { + "resolved": "../../node_modules/.pnpm/body-parser@1.20.2/node_modules/body-parser", + "link": true + }, + "node_modules/cors": { + "resolved": "../../node_modules/.pnpm/cors@2.8.5/node_modules/cors", + "link": true + }, + "node_modules/dataloader": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/dataloader/-/dataloader-2.2.2.tgz", + "integrity": "sha512-8YnDaaf7N3k/q5HnTJVuzSyLETjoZjVmHc4AeKAzOvKHEFQKcn64OKBfzHYtE9zGjctNM7V9I0MfnUVLpi7M5g==" + }, + "node_modules/env-cmd": { + "resolved": "../../node_modules/.pnpm/env-cmd@10.1.0/node_modules/env-cmd", + "link": true + }, + "node_modules/ethers": { + "resolved": "../../node_modules/.pnpm/ethers@5.7.2/node_modules/ethers", + "link": true + }, + "node_modules/express": { + "resolved": "../../node_modules/.pnpm/express@4.18.2/node_modules/express", + "link": true + }, + "node_modules/follow-redirects": { + "version": "1.15.2", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz", + "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/fs": { + "resolved": "../../node_modules/.pnpm/fs@0.0.1-security/node_modules/fs", + "link": true + }, + "node_modules/ipfs-unixfs": { + "resolved": "../../node_modules/.pnpm/ipfs-unixfs@11.0.1/node_modules/ipfs-unixfs", + "link": true + }, + "node_modules/jssha": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/jssha/-/jssha-3.2.0.tgz", + "integrity": "sha512-QuruyBENDWdN4tZwJbQq7/eAK85FqrI4oDbXjy5IBhYD+2pTJyBUWZe8ctWaCkrV0gy6AaelgOZZBMeswEa/6Q==", + "engines": { + "node": "*" + } + }, + "node_modules/multiformats": { + "resolved": "../../node_modules/.pnpm/multiformats@12.0.1/node_modules/multiformats", + "link": true + }, + "node_modules/path": { + "resolved": "../../node_modules/.pnpm/path@0.12.7/node_modules/path", + "link": true + }, + "node_modules/symbol.inspect": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/symbol.inspect/-/symbol.inspect-1.0.1.tgz", + "integrity": "sha512-YQSL4duoHmLhsTD1Pw8RW6TZ5MaTX5rXJnqacJottr2P2LZBF/Yvrc3ku4NUpMOm8aM0KOCqM+UAkMA5HWQCzQ==" + }, + "node_modules/teslabot": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/teslabot/-/teslabot-1.5.0.tgz", + "integrity": "sha512-e2MmELhCgrgZEGo7PQu/6bmYG36IDH+YrBI1iGm6jovXkeDIGa3pZ2WSqRjzkuw2vt1EqfkZoV5GpXgqL8QJVg==" + }, + "node_modules/ton": { + "version": "13.6.1", + "resolved": "https://registry.npmjs.org/ton/-/ton-13.6.1.tgz", + "integrity": "sha512-CZlFsmO+l+uPSI2zgnUd8zCS5XuWnUSFRVUjRGl5X5fKXYnjaVba4vMaIyFTJwel+uEMnolGMSlNP8DAa9mfVg==", + "dependencies": { + "axios": "^0.25.0", + "dataloader": "^2.0.0", + "symbol.inspect": "1.0.1", + "teslabot": "^1.3.0", + "zod": "^3.21.4" + }, + "peerDependencies": { + "ton-core": ">=0.51.0", + "ton-crypto": ">=3.2.0" + } + }, + "node_modules/ton-core": { + "version": "0.52.0", + "resolved": "https://registry.npmjs.org/ton-core/-/ton-core-0.52.0.tgz", + "integrity": "sha512-9X6HZsO87i78tk5LBW+OKxtpSZU9L8GznMwhzrmNIySj+oFCq1/fi7yJhLVb7KMvzcInLZc2Kmm7H3pzQnCBiw==", + "peer": true, + "dependencies": { + "symbol.inspect": "1.0.1" + }, + "peerDependencies": { + "ton-crypto": ">=3.2.0" + } + }, + "node_modules/ton-crypto": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ton-crypto/-/ton-crypto-3.2.0.tgz", + "integrity": "sha512-fltdBNQ45gARMuGMEOjPZWPJ5eSql8p3CA0Dj7tPv5lhU5ziT8SxXLAzDraR9HJ8YpjBHLVvYyhMLRiEwxgtMQ==", + "dependencies": { + "jssha": "3.2.0", + "ton-crypto-primitives": "2.0.0", + "tweetnacl": "1.0.3" + } + }, + "node_modules/ton-crypto-primitives": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ton-crypto-primitives/-/ton-crypto-primitives-2.0.0.tgz", + "integrity": "sha512-K+qKjpS0h9sPW6oExcpxnzuQ7nEgHEiDKwIqE/jWD25o8iFGe3FWj1gKxFNbKE9wwYKc5IV8FwrU+raF0KO5nQ==", + "dependencies": { + "jssha": "3.2.0" + } + }, + "node_modules/tweetnacl": { + "version": "1.0.3", + "license": "Unlicense" + }, + "node_modules/zod": { + "version": "3.22.2", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.22.2.tgz", + "integrity": "sha512-wvWkphh5WQsJbVk1tbx1l1Ly4yg+XecD+Mq280uBGt9wa5BKSWf4Mhp6GmrkPixhMxmabYY7RbzlwVP32pbGCg==", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + } + } +} diff --git a/apps/backend/package.json b/apps/backend/package.json index 064a9d7..2fdfe78 100644 --- a/apps/backend/package.json +++ b/apps/backend/package.json @@ -24,6 +24,8 @@ "fs": "^0.0.1-security", "ipfs-unixfs": "^11.0.1", "multiformats": "^12.0.1", - "path": "^0.12.7" + "path": "^0.12.7", + "ton": "^13.6.1", + "ton-crypto": "^3.2.0" } } diff --git a/apps/backend/server.js b/apps/backend/server.js index d4486b2..15eaebc 100644 --- a/apps/backend/server.js +++ b/apps/backend/server.js @@ -1,10 +1,11 @@ import { createRequire } from 'module'; import { add_asset } from './src/co2storage/add_asset.js'; import { sign_cid } from './src/co2storage/sign_cid.js'; -import { search_asset, search_proven } from './src/co2storage/search.js'; +import { search_asset, search_proven, search_assets } from './src/co2storage/search.js'; import { buy_power } from './src/buy_power.js'; import { fetch_cert_address } from './src/hypercert/hypercert.js'; import { mint_hypercert } from './src/blockchain/blockchain.js'; +import { mint_nft } from './src/TON/add_ton_sale.js'; import cors from 'cors'; @@ -111,6 +112,43 @@ app.get('/approve', function (req, res) { } }) +app.post('/add_ton_asset', async function (req, res) { + const req_data = req.body + console.log("add_asset_req:") + console.log(req_data) + + + try{ + let nft_address = await mint_nft(req_data.provider) + console.log(nft_address) + add_asset(req_data.capacity, nft_address, req_data.date, req_data.type, req_data.location).then(asset_res=>{ + console.log("Asset respond:") + console.log(asset_res.result.asset[5].file) + res.send("ok!") + }).catch(err=>{ + console.log(err) + res.send("bad") + }) + }catch(err){ + console.log(err) + res.send("bad") + } +}) + +app.post('/assets', function (req, res) { + const req_data = req.body + console.log("asset_req:") + console.log(req_data) + try{ + search_assets(req_data.address).then(rres=>{ + console.log(rres) + res.send(rres) + }) + }catch(err){ + console.log(err) + } +}) + var server = app.listen(8080, function () { diff --git a/apps/backend/src/TON/add_ton_sale.js b/apps/backend/src/TON/add_ton_sale.js new file mode 100644 index 0000000..545964a --- /dev/null +++ b/apps/backend/src/TON/add_ton_sale.js @@ -0,0 +1,83 @@ +import { getitem } from "./search_ton_asset.js"; +import { openWallet } from "./src/utils.js"; +import { Collection } from "./src/contracts/NftCollection.js"; +import { waitSeqno } from "./src/delay.js"; +import { Address, toNano } from "ton-core"; +import { NftItem } from "./src/contracts/NftItem.js"; +import { NftMarketplace } from "./src/contracts/NftMarketplace.js" +import { NftSale } from "./src/contracts/Sales.js"; + + + +export async function mint_nft(provider){ + const nft = await getitem() + const index = nft.length + try{ + let nft_address = await Mint(index) + Salenft(index, provider) + return nft_address + }catch(err){ + console.log(err) + } +} + +async function Mint(index) { + const wallet = await openWallet(process.env.MNEMONIC.split(" "), true); + const collectionData = { + ownerAddress: wallet.contract.address, + royaltyPercent: 0, // 0.05 = 5% + royaltyAddress: wallet.contract.address, + nextItemIndex: 0, + collectionContentUrl: `ipfs://`, + commonContentUrl: `ipfs://`, + }; + const collection = new Collection(collectionData); + + console.log(`Start deploy of NFT`); + const mintParams = { + queryId: 0, + itemOwnerAddress: wallet.contract.address, + itemIndex: index, + amount: toNano("0.05"), + commonContentUrl: "", + }; + + const nftItem = new NftItem(collection); + const seqno = await nftItem.deploy(wallet, mintParams); + console.log(`Successfully deployed NFT`); + await waitSeqno(seqno, wallet); + return (await NftItem.getAddressByIndex(collection.address, index)).toRawString() +} + +async function Salenft(index, provider) { + const wallet = await openWallet(process.env.MNEMONIC.split(" "), true); + const collectionData = { + ownerAddress: wallet.contract.address, + royaltyPercent: 0, // 0.05 = 5% + royaltyAddress: wallet.contract.address, + nextItemIndex: 0, + collectionContentUrl: `ipfs://`, + commonContentUrl: `ipfs://`, + }; + const collection = new Collection(collectionData); + const marketplace = new NftMarketplace(wallet.contract.address); + const nftToSaleAddress = await NftItem.getAddressByIndex(collection.address, index); + + const saleData = { + isComplete: false, + createdAt: Math.ceil(Date.now() / 1000), + marketplaceAddress: marketplace.address, + nftAddress: nftToSaleAddress, + nftOwnerAddress: Address.parse(provider), + fullPrice: toNano("1"), + marketplaceFeeAddress: wallet.contract.address, + marketplaceFee: toNano("0"), + royaltyAddress: wallet.contract.address, + royaltyAmount: toNano("0"), + }; + const nftSaleContract = new NftSale(saleData); + const seqno = await nftSaleContract.deploy(wallet); + await waitSeqno(seqno, wallet); + + NftItem.transfer(wallet, nftSaleContract.address, nftToSaleAddress); +} \ No newline at end of file diff --git a/apps/backend/src/TON/search_ton_asset.js b/apps/backend/src/TON/search_ton_asset.js new file mode 100644 index 0000000..ef8209f --- /dev/null +++ b/apps/backend/src/TON/search_ton_asset.js @@ -0,0 +1,17 @@ +import axios from "axios"; + + +export async function getitem() { + try { + const res = await axios({ + method: 'get', + url: `https://testnet.tonapi.io/v2/nfts/collections/EQDW1G_c_xIb2Iyzof123IAzQlY942Pl3H6XEJ_jRB2ez-Pe/items?limit=1000&offset=0`, + }) + console.log(res) + return res.data["nft_items"] + } + catch (err) { + console.log("error", err); + } +} + diff --git a/apps/backend/src/TON/src/contracts/NftCollection.js b/apps/backend/src/TON/src/contracts/NftCollection.js new file mode 100644 index 0000000..28e3db4 --- /dev/null +++ b/apps/backend/src/TON/src/contracts/NftCollection.js @@ -0,0 +1,126 @@ +import { + Cell, + internal, + beginCell, + contractAddress, + SendMode, + } from "ton-core"; + import { encodeOffChainContent } from "../utils.js"; + + + + export class Collection { + collectionData; + + constructor(collectionData) { + this.collectionData = collectionData; + } + + createCodeCell() { + const NftCollectionCodeBoc = + "te6cckECFAEAAh8AART/APSkE/S88sgLAQIBYgkCAgEgBAMAJbyC32omh9IGmf6mpqGC3oahgsQCASAIBQIBIAcGAC209H2omh9IGmf6mpqGAovgngCOAD4AsAAvtdr9qJofSBpn+pqahg2IOhph+mH/SAYQAEO4tdMe1E0PpA0z/U1NQwECRfBNDUMdQw0HHIywcBzxbMyYAgLNDwoCASAMCwA9Ra8ARwIfAFd4AYyMsFWM8WUAT6AhPLaxLMzMlx+wCAIBIA4NABs+QB0yMsCEsoHy//J0IAAtAHIyz/4KM8WyXAgyMsBE/QA9ADLAMmAE59EGOASK3wAOhpgYC42Eit8H0gGADpj+mf9qJofSBpn+pqahhBCDSenKgpQF1HFBuvgoDoQQhUZYBWuEAIZGWCqALnixJ9AQpltQnlj+WfgOeLZMAgfYBwGyi544L5cMiS4ADxgRLgAXGBEuAB8YEYGYHgAkExIREAA8jhXU1DAQNEEwyFAFzxYTyz/MzMzJ7VTgXwSED/LwACwyNAH6QDBBRMhQBc8WE8s/zMzMye1UAKY1cAPUMI43gED0lm+lII4pBqQggQD6vpPywY/egQGTIaBTJbvy9AL6ANQwIlRLMPAGI7qTAqQC3gSSbCHis+YwMlBEQxPIUAXPFhPLP8zMzMntVABgNQLTP1MTu/LhklMTugH6ANQwKBA0WfAGjhIBpENDyFAFzxYTyz/MzMzJ7VSSXwXiN0CayQ=="; + return Cell.fromBase64(NftCollectionCodeBoc); + } + + createDataCell() { + const data = this.collectionData; + const dataCell = beginCell(); + + dataCell.storeAddress(data.ownerAddress); + dataCell.storeUint(data.nextItemIndex, 64); + + const contentCell = beginCell(); + + const collectionContent = encodeOffChainContent(data.collectionContentUrl); + + const commonContent = beginCell(); + commonContent.storeBuffer(Buffer.from(data.commonContentUrl)); + + contentCell.storeRef(collectionContent); + contentCell.storeRef(commonContent.asCell()); + dataCell.storeRef(contentCell); + const NftItemCodeCell = Cell.fromBase64( + "te6cckECDQEAAdAAART/APSkE/S88sgLAQIBYgMCAAmhH5/gBQICzgcEAgEgBgUAHQDyMs/WM8WAc8WzMntVIAA7O1E0NM/+kAg10nCAJp/AfpA1DAQJBAj4DBwWW1tgAgEgCQgAET6RDBwuvLhTYALXDIhxwCSXwPg0NMDAXGwkl8D4PpA+kAx+gAxcdch+gAx+gAw8AIEs44UMGwiNFIyxwXy4ZUB+kDUMBAj8APgBtMf0z+CEF/MPRRSMLqOhzIQN14yQBPgMDQ0NTWCEC/LJqISuuMCXwSED/LwgCwoAcnCCEIt3FzUFyMv/UATPFhAkgEBwgBDIywVQB88WUAX6AhXLahLLH8s/Im6zlFjPFwGRMuIByQH7AAH2UTXHBfLhkfpAIfAB+kDSADH6AIIK+vCAG6EhlFMVoKHeItcLAcMAIJIGoZE24iDC//LhkiGOPoIQBRONkchQCc8WUAvPFnEkSRRURqBwgBDIywVQB88WUAX6AhXLahLLH8s/Im6zlFjPFwGRMuIByQH7ABBHlBAqN1viDACCAo41JvABghDVMnbbEDdEAG1xcIAQyMsFUAfPFlAF+gIVy2oSyx/LPyJus5RYzxcBkTLiAckB+wCTMDI04lUC8ANqhGIu" + ); + dataCell.storeRef(NftItemCodeCell); + const royaltyBase = 1000; + const royaltyFactor = Math.floor(data.royaltyPercent * royaltyBase); + + const royaltyCell = beginCell(); + royaltyCell.storeUint(royaltyFactor, 16); + royaltyCell.storeUint(royaltyBase, 16); + royaltyCell.storeAddress(data.royaltyAddress); + dataCell.storeRef(royaltyCell); + + return dataCell.endCell(); + } + + get stateInit() { + const code = this.createCodeCell(); + const data = this.createDataCell(); + + return { code, data }; + } + + get address() { + return contractAddress(0, this.stateInit); + } + + async deploy(wallet) { + const seqno = await wallet.contract.getSeqno(); + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: "0.05", + to: this.address, + init: this.stateInit, + }), + ], + sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS, + }); + return seqno; + } + + async topUpBalance( + wallet, + nftAmount + ) { + const feeAmount = 0.026 // approximate value of fees for 1 transaction in our case + const seqno = await wallet.contract.getSeqno(); + const amount = nftAmount * feeAmount; + + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: amount.toString(), + to: this.address.toString({ bounceable: false }), + body: new Cell(), + }), + ], + sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS, + }); + + return seqno; + } + + createMintBody(params){ + const body = beginCell(); + body.storeUint(1, 32); + body.storeUint(params.queryId || 0, 64); + body.storeUint(params.itemIndex, 64); + body.storeCoins(params.amount); + const nftItemContent = beginCell(); + nftItemContent.storeAddress(params.itemOwnerAddress); + + const uriContent = beginCell(); + uriContent.storeBuffer(Buffer.from(params.commonContentUrl)); + nftItemContent.storeRef(uriContent.endCell()); + + body.storeRef(nftItemContent.endCell()); + return body.endCell(); + } +} diff --git a/apps/backend/src/TON/src/contracts/NftItem.js b/apps/backend/src/TON/src/contracts/NftItem.js new file mode 100644 index 0000000..004db6f --- /dev/null +++ b/apps/backend/src/TON/src/contracts/NftItem.js @@ -0,0 +1,86 @@ +import { Address, beginCell, Cell, internal, SendMode } from "ton-core"; +import { TonClient } from "ton"; + +export class NftItem { + collection; + + constructor(collection) { + this.collection = collection; + } + + async deploy( + wallet, + params + ){ + const seqno = await wallet.contract.getSeqno(); + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: "0.05", + to: this.collection.address, + body: this.collection.createMintBody(params), + }), + ], + sendMode: SendMode.IGNORE_ERRORS + SendMode.PAY_GAS_SEPARATELY, + }); + return seqno; + } + + static async getAddressByIndex( + collectionAddress, + itemIndex + ) { + const client = new TonClient({ + endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC", + apiKey: process.env.TONCENTER_API_KEY, + }); + + const response = await client.runMethod( + collectionAddress, + "get_nft_address_by_index", + [{ type: "int", value: BigInt(itemIndex) }] + ); + return response.stack.readAddress(); + } + + static createTransferBody(params) { + const msgBody = beginCell(); + msgBody.storeUint(0x5fcc3d14, 32); // op-code + msgBody.storeUint(0, 64); // query-id + msgBody.storeAddress(params.newOwner); + msgBody.storeAddress(params.responseTo || null); + msgBody.storeBit(false); // no custom payload + msgBody.storeCoins(params.forwardAmount || 0); + msgBody.storeBit(0); // no forward_payload + + return msgBody.endCell(); + } + + + static async transfer( + wallet, + new_owner, + itemaddress + ) { + const seqno = await wallet.contract.getSeqno(); + const body = NftItem.createTransferBody({newOwner:new_owner, responseTo: wallet.contract.address}) + + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: "0.05", + to: itemaddress, + body: body, + }), + ], + sendMode: SendMode.IGNORE_ERRORS + SendMode.PAY_GAS_SEPARATELY, + }); + return seqno; + } + + +} \ No newline at end of file diff --git a/apps/backend/src/TON/src/contracts/NftMarketplace.js b/apps/backend/src/TON/src/contracts/NftMarketplace.js new file mode 100644 index 0000000..18cc76c --- /dev/null +++ b/apps/backend/src/TON/src/contracts/NftMarketplace.js @@ -0,0 +1,58 @@ +import { + Address, + beginCell, + Cell, + contractAddress, + internal, + SendMode, + } from "ton-core"; + + export class NftMarketplace { + ownerAddress; + + constructor(ownerAddress) { + this.ownerAddress = ownerAddress; + } + + + get stateInit(){ + const code = this.createCodeCell(); + const data = this.createDataCell(); + + return { code, data }; + } + + createDataCell(){ + const dataCell = beginCell(); + + dataCell.storeAddress(this.ownerAddress); + + return dataCell.endCell(); + } + + createCodeCell(){ + const NftMarketplaceCodeBoc = "te6cckEBBAEAbQABFP8A9KQT9LzyyAsBAgEgAgMAqtIyIccAkVvg0NMDAXGwkVvg+kDtRND6QDASxwXy4ZEB0x8BwAGOK/oAMAHU1DAh+QBwyMoHy//J0Hd0gBjIywXLAljPFlAE+gITy2vMzMlx+wCRW+IABPIwjvfM5w=="; + return Cell.fromBase64(NftMarketplaceCodeBoc) + } + + get address() { + return contractAddress(0, this.stateInit); + } + + async deploy(wallet) { + const seqno = await wallet.contract.getSeqno(); + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: "0.5", + to: this.address, + init: this.stateInit, + }), + ], + sendMode: SendMode.IGNORE_ERRORS + SendMode.PAY_GAS_SEPARATELY, + }); + return seqno; + } + } \ No newline at end of file diff --git a/apps/backend/src/TON/src/contracts/Sales.js b/apps/backend/src/TON/src/contracts/Sales.js new file mode 100644 index 0000000..b44b5b9 --- /dev/null +++ b/apps/backend/src/TON/src/contracts/Sales.js @@ -0,0 +1,124 @@ +import { + Address, + beginCell, + Cell, + contractAddress, + internal, + SendMode, + storeStateInit, + toNano, +} from "ton-core"; + + + export class NftSale { + data + constructor(data) { + this.data = data; + } + + createDataCell() { + const saleData = this.data; + + const feesCell = beginCell(); + + feesCell.storeAddress(saleData.marketplaceFeeAddress); + feesCell.storeCoins(saleData.marketplaceFee); + feesCell.storeAddress(saleData.royaltyAddress); + feesCell.storeCoins(saleData.royaltyAmount); + + const dataCell = beginCell(); + dataCell.storeUint(saleData.isComplete ? 1 : 0, 1); + dataCell.storeUint(saleData.createdAt, 32); + dataCell.storeAddress(saleData.marketplaceAddress); + dataCell.storeAddress(saleData.nftAddress); + dataCell.storeAddress(saleData.nftOwnerAddress); + dataCell.storeCoins(saleData.fullPrice); + dataCell.storeRef(feesCell.endCell()); + dataCell.storeUint(1,1) + + return dataCell.endCell(); + } + + get address() { + return contractAddress(0, this.stateInit); + } + + get stateInit() { + const code = this.createCodeCell(); + const data = this.createDataCell(); + + return { code, data }; + } + + createCodeCell(){ + const NftFixPriceSaleV2CodeBoc = + "te6cckECDAEAAikAART/APSkE/S88sgLAQIBIAMCAATyMAIBSAUEAFGgOFnaiaGmAaY/9IH0gfSB9AGoYaH0gfQB9IH0AGEEIIySsKAVgAKrAQICzQgGAfdmCEDuaygBSYKBSML7y4cIk0PpA+gD6QPoAMFOSoSGhUIehFqBSkHCAEMjLBVADzxYB+gLLaslx+wAlwgAl10nCArCOF1BFcIAQyMsFUAPPFgH6AstqyXH7ABAjkjQ04lpwgBDIywVQA88WAfoCy2rJcfsAcCCCEF/MPRSBwCCIYAYyMsFKs8WIfoCy2rLHxPLPyPPFlADzxbKACH6AsoAyYMG+wBxVVAGyMsAFcsfUAPPFgHPFgHPFgH6AszJ7VQC99AOhpgYC42EkvgnB9IBh2omhpgGmP/SB9IH0gfQBqGBNgAPloyhFrpOEBWccgGRwcKaDjgskvhHAoomOC+XD6AmmPwQgCicbIiV15cPrpn5j9IBggKwNkZYAK5Y+oAeeLAOeLAOeLAP0BZmT2qnAbE+OAcYED6Y/pn5gQwLCQFKwAGSXwvgIcACnzEQSRA4R2AQJRAkECPwBeA6wAPjAl8JhA/y8AoAyoIQO5rKABi+8uHJU0bHBVFSxwUVsfLhynAgghBfzD0UIYAQyMsFKM8WIfoCy2rLHxnLPyfPFifPFhjKACf6AhfKAMmAQPsAcQZQREUVBsjLABXLH1ADzxYBzxYBzxYB+gLMye1UABY3EDhHZRRDMHDwBTThaBI="; + + return Cell.fromBase64(NftFixPriceSaleV2CodeBoc); + } + + async deploy(wallet) { + const stateInit = beginCell() + .store(storeStateInit(this.stateInit)) + .endCell(); + const payload = beginCell(); + payload.storeUint(1, 32); + payload.storeCoins(toNano("0.05")); + payload.storeRef(stateInit); + payload.storeRef(new Cell()); + const seqno = await wallet.contract.getSeqno(); + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: "0.05", + to: this.data.marketplaceAddress, + body: payload.endCell(), + }), + ], + sendMode: SendMode.IGNORE_ERRORS + SendMode.PAY_GAS_SEPARATELY, + }); + return seqno; + } + + async buy(wallet,address) { + const stateInit = beginCell() + .store(storeStateInit(this.stateInit)) + .endCell(); + const payload = beginCell(); + payload.storeUint(0, 32);//opcode + payload.storeCoins(toNano("0.05")); + + const seqno = await wallet.contract.getSeqno(); + await wallet.contract.sendTransfer({ + seqno, + secretKey: wallet.keyPair.secretKey, + messages: [ + internal({ + value: "4.5", + to: address + }), + ], + sendMode: SendMode.IGNORE_ERRORS + SendMode.PAY_GAS_SEPARATELY, + }); + /* let deployLink = + 'https://app.tonkeeper.com/transfer/' + + address.toString({ + testOnly: true, + }) + + "?" + + qs.stringify({ + amount: toNano("1.5").toString(10), + bin: payload.endCell().toBoc({idx: false}).toString("base64"), + }); + + console.log(deployLink) + + qrcode.generate(deployLink, {small: true }, (qr) => { + console.log(qr); + }); + */ + return 0; + } + } \ No newline at end of file diff --git a/apps/backend/src/TON/src/delay.js b/apps/backend/src/TON/src/delay.js new file mode 100644 index 0000000..ab7ce8c --- /dev/null +++ b/apps/backend/src/TON/src/delay.js @@ -0,0 +1,12 @@ + +export async function waitSeqno(seqno, wallet) { + for (let attempt = 0; attempt < 10; attempt++) { + await sleep(2000); + const seqnoAfter = await wallet.contract.getSeqno(); + if (seqnoAfter == seqno + 1) break; + } +} + +export function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} \ No newline at end of file diff --git a/apps/backend/src/TON/src/metadata.js b/apps/backend/src/TON/src/metadata.js new file mode 100644 index 0000000..0218dec --- /dev/null +++ b/apps/backend/src/TON/src/metadata.js @@ -0,0 +1,31 @@ +import pinataSDK from "@pinata/sdk"; +import { readdirSync } from "fs"; +import { writeFile, readFile } from "fs/promises"; +import path from "path"; + +export async function uploadFolderToIPFS(folderPath) { + const pinata = new pinataSDK({ + pinataApiKey: process.env.PINATA_API_KEY, + pinataSecretApiKey: process.env.PINATA_API_SECRET, + }); + + const response = await pinata.pinFromFS(folderPath); + return response.IpfsHash; + } + + export async function updateMetadataFiles(metadataFolderPath, imagesIpfsHas) { + const files = readdirSync(metadataFolderPath); + + files.forEach(async (filename, index) => { + const filePath = path.join(metadataFolderPath, filename) + const file = await readFile(filePath); + + const metadata = JSON.parse(file.toString()); + metadata.image = + index != files.length - 1 + ? `ipfs://${imagesIpfsHash}/${index}.jpg` + : `ipfs://${imagesIpfsHash}/logo.jpg`; + + await writeFile(filePath, JSON.stringify(metadata)); + }); + } \ No newline at end of file diff --git a/apps/backend/src/TON/src/utils.js b/apps/backend/src/TON/src/utils.js new file mode 100644 index 0000000..638074c --- /dev/null +++ b/apps/backend/src/TON/src/utils.js @@ -0,0 +1,71 @@ +import { mnemonicToPrivateKey } from "ton-crypto"; +import { + beginCell, + TonClient, + WalletContractV4, +} from "ton"; + + +export async function openWallet(mnemonic, testnet) { + const keyPair = await mnemonicToPrivateKey(mnemonic); + const toncenterBaseEndpoint = testnet + ? "https://testnet.toncenter.com" + : "https://toncenter.com"; + + const client = new TonClient({ + endpoint: `${toncenterBaseEndpoint}/api/v2/jsonRPC`, + apiKey: process.env.TONCENTER_API_KEY, + }); + + const wallet = WalletContractV4.create({ + workchain: 0, + publicKey: keyPair.publicKey, + }); + + const contract = client.open(wallet); + return { contract, keyPair }; +} + +function bufferToChunks(buff, chunkSize) { + const chunks = []; + while (buff.byteLength > 0) { + chunks.push(buff.subarray(0, chunkSize)); + buff = buff.subarray(chunkSize); + } + return chunks; + } + + function makeSnakeCell(data) { + const chunks = bufferToChunks(data, 127); + + if (chunks.length === 0) { + return beginCell().endCell(); + } + + if (chunks.length === 1) { + return beginCell().storeBuffer(chunks[0]).endCell(); + } + + let curCell = beginCell(); + + for (let i = chunks.length - 1; i >= 0; i--) { + const chunk = chunks[i]; + + curCell.storeBuffer(chunk); + + if (i - 1 >= 0) { + const nextCell = beginCell(); + nextCell.storeRef(curCell); + curCell = nextCell; + } + } + + return curCell.endCell(); + } + + export function encodeOffChainContent(content) { + let data = Buffer.from(content); + const offChainPrefix = Buffer.from([0x01]); + data = Buffer.concat([offChainPrefix, data]); + return makeSnakeCell(data); + } \ No newline at end of file diff --git a/apps/backend/src/co2storage/search.js b/apps/backend/src/co2storage/search.js index e5b7961..6a5f08f 100644 --- a/apps/backend/src/co2storage/search.js +++ b/apps/backend/src/co2storage/search.js @@ -127,4 +127,74 @@ export async function search_proven(address, cid){ } //search_asset("0xf3419771c2551f88a91Db61cB874347f05640172") -//search_proven("0xf3419771c2551f88a91Db61cB874347f05640172", "bafyreielhkdjwgluc3vi6vobzmvvnrbodea3oguxvsnpflpiuldkn4uv24") \ No newline at end of file +//search_proven("0xf3419771c2551f88a91Db61cB874347f05640172", "bafyreielhkdjwgluc3vi6vobzmvvnrbodea3oguxvsnpflpiuldkn4uv24") + +export async function search_ton_asset(address){ + const authType = "pk" + const ipfsNodeType = "client" + //const ipfsNodeAddr = "/ip4/127.0.0.1/tcp/5001" + //const fgApiUrl = "http://localhost:3020" + const ipfsNodeAddr = "/dns4/web1.co2.storage/tcp/5002/https" + const fgApiUrl = "https://web1.co2.storage" + + const fgStorage = new FGStorage({authType: authType, ipfsNodeType: ipfsNodeType, ipfsNodeAddr: ipfsNodeAddr, fgApiHost: fgApiUrl}) + + /** + * Search + * parameters: (chainName, phrases, dataStructure, cid, parent, name, description, base, + 1reference, 1contentCid, 1creator, 1createdFrom, 1createdTo, 1version, offset, limit, sortBy, sortDir) + */ + const keyword = 'GreenPower txs '+ address + let searchResponse = await fgStorage.searchAssets('GreenPower', null, null, keyword, null, null, 0, 50, null, null) + if(searchResponse.error != null) { + console.error(searchResponse.error) + await new Promise(reject => setTimeout(reject, 300)); + } + + let asset_list = [] + + searchResponse.result.assets.forEach(item => { + const obj = new Promise((resolve)=>{ + resolve(fgStorage.getAsset(item.block)) + }) + asset_list.push (obj) + }); + + let res_list = [] + await Promise.all(asset_list).then(list=>{ + list.forEach(asset=>{ + res_list.push({cid:asset.result.assetBlock.cid,asset:asset.result.asset}) + }) + }).catch(err=>{ + console.log(err) + }) + + //delete duplicated + let cid_list = [] + let t = '' + res_list.forEach(item=>{ + if(item.cid !== t){ + cid_list.push(item) + t = item.cid + } + }) + return cid_list[0] +} + +export async function search_assets(addresses){ + let asset_list = [] + addresses.forEach(address=>{ + const obj = new Promise((resolve)=>{ + resolve(search_ton_asset(address)) + }) + asset_list.push(obj); + }) + let rres = [] + await Promise.all(asset_list).then(res=>{ + console.log("search complete:") + console.log(res) + rres = res + }).catch(err=>console.log(err)) + + return rres +} \ No newline at end of file diff --git a/apps/backend/undefined.json b/apps/backend/undefined.json index 404b081..17edbc3 100644 --- a/apps/backend/undefined.json +++ b/apps/backend/undefined.json @@ -1 +1 @@ -{"name":"Green Power Transaction","description":"Generation capacity(KW): 14500\nPower Type: Hydro\nLocation: TW","image":"data:image/png;base64, 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","version":"0.0.1","hypercert":{"impact_scope":{"name":"Impact Scope","value":["all"],"excludes":[""],"display_value":"all"},"work_scope":{"name":"Work Scope","value":["Green Power"],"excludes":[""],"display_value":"Green Power"},"impact_timeframe":{"name":"Impact Timeframe","value":[1692144000,1692144000],"excludes":[""],"display_value":"2023-02-01 → 2023-02-28"},"work_timeframe":{"name":"Work Timeframe","value":[1692144000,1692403200],"excludes":[""],"display_value":"2023-02-01 → 2023-02-28"},"rights":{"name":"Rights","value":["Public Display"],"excludes":[""],"display_value":"Public Display"},"contributors":{"name":"Contributors","value":[null],"excludes":[""]}},"external_url":""} \ No newline at end of file +{"name":"Green Power Transaction","description":"Generation capacity(KW): 9500\nPower Type: Hydro\nLocation: Taipei\nEnrollment: Fri Sep 15 2023 08:40:34 GMT+0800 (台北標準時間)","image":"data:image/png;base64, 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","version":"0.0.1","hypercert":{"impact_scope":{"name":"Impact Scope","value":["all"],"excludes":[""],"display_value":"all"},"work_scope":{"name":"Work Scope","value":["Green Power"],"excludes":[""],"display_value":"Green Power"},"impact_timeframe":{"name":"Impact Timeframe","value":[1692144000,1692144000],"excludes":[""],"display_value":"2023-02-01 → 2023-02-28"},"work_timeframe":{"name":"Work Timeframe","value":[1692144000,1692403200],"excludes":[""],"display_value":"2023-02-01 → 2023-02-28"},"rights":{"name":"Rights","value":["Public Display"],"excludes":[""],"display_value":"Public Display"},"contributors":{"name":"Contributors","value":[null],"excludes":[""]}},"external_url":""} \ No newline at end of file diff --git a/apps/ton-web/components/buyerTable.tsx b/apps/ton-web/components/buyerTable.tsx index 76b99dc..f3e88ec 100644 --- a/apps/ton-web/components/buyerTable.tsx +++ b/apps/ton-web/components/buyerTable.tsx @@ -1,44 +1,50 @@ import BuyerTableItem from "./buyerTableItem"; import { formatAddress } from "../utils/stringify"; +import { get_ton_Asset } from "../service/api"; +import { useQuery } from "@tanstack/react-query"; +import Loading from "./loading"; + function BuyerTable(props: any) { - console.log(props.claimToken); + console.log(props.sales) + let sale_address: any[] = [] + props.sales.forEach((sale: any)=> { + sale_address.push(sale["address"]) + }); + const { isLoading, error, data } = useQuery({ + queryKey: ["get_ton_Asset"], + queryFn: () => + get_ton_Asset(sale_address).then((res:any) => { + return res + }), + retry: 10, + cacheTime: 1000*60*5 +}); + return ( -
- | TokenId | -units | -- |
---|
NFT ID: {props.index}
+Generation_capacity: {props.Generation_capacity}
+Prize: {props.price}
+