Merge pull request #124 from walt-id/feat/Algorand-support

Feat/algorand support

build.gradle.kts

@@ -72,6 +72,9 @@ dependencies {
     // unique
     implementation ("network.unique:unique-sdk-jvm:0.0.1")
 
+    // algorand
+    implementation ("com.algorand:algosdk:2.2.0")
+
     // expediagroup graphql
     implementation("com.expediagroup:graphql-kotlin-spring-client:6.4.0")
     implementation("com.expediagroup", "graphql-kotlin-client-serialization", "6.4.0")

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+zipStorePath=wrapper/dists

js/app.ts

@@ -10,12 +10,11 @@ import {NearRoutes} from './near/near.routes.config';
 import {FlowRoutes} from './Flow/flow.routes.config';
 import {PolkadotRoutes} from './polkadot/polkadot.routes.config';
 
-
 import debug from 'debug';
 
 const app: express.Application = express();
 const server: http.Server = http.createServer(app);
-const port = 3000;
+const port = 4000;
 const routes: Array<CommonRoutesConfig> = [];
 const debugLog: debug.IDebugger = debug('app');
 
@@ -57,4 +56,4 @@ server.listen(port, () => {
     routes.forEach((route: CommonRoutesConfig) => {
         debugLog(`Routes configured for ${route.getName()}`);
     });
-});
+});

js/package.json

@@ -28,6 +28,7 @@
     "winston": "^3.8.2"
   },
   "devDependencies": {
+    "@types/bn.js": "^5.1.1",
     "@types/cors": "^2.8.12",
     "@types/debug": "^4.1.7",
     "@types/express": "^4.17.14",

src/main/kotlin/id/walt/nftkit/App.kt

@@ -1,14 +1,15 @@
 package id.walt.nftkit
 
+
 import id.walt.nftkit.rest.NftKitApi
 
 
 fun main() {
     println("\n\n\n")
-
     /* /////////// */
     /* /////////// */
     /* /////////// */
+
     NftKitApi.start()
 
 

src/main/kotlin/id/walt/nftkit/Values.kt

@@ -40,4 +40,17 @@ object Values {
     const val POLKADOT_UNIQUE_EXPLORER = "https://unique.subscan.io/"
     const val POLKADOT_OPAL_EXPLORER = "https://uniquescan.io/OPAL/"
 
+
+    //algorand values
+    const val ALGORAND_INDEXER_TESTNET= "https://testnet-algorand.api.purestake.io/idx2";
+    const val ALGORAND_INDEXER_MAINNET= "https://mainnet-algorand.api.purestake.io/idx2";
+
+    const val ALGORAND_ALGOD_TESTNET = "https://testnet-algorand.api.purestake.io/ps2";
+    const val ALGORAND_ALGOD_MAINNET = "https://mainnet-algorand.api.purestake.io/ps2";
+
+
+
+    const val ALGORAND_MAINNET_EXPLORER = "https://algoexplorer.io/"
+    const val ALGORAND_TESTNET_EXPLORER = "https://testnet.algoexplorer.io/"
+
 }

src/main/kotlin/id/walt/nftkit/rest/AlgorandNftController.kt

@@ -0,0 +1,125 @@
+package id.walt.nftkit.rest
+
+import cc.vileda.openapi.dsl.schema
+
+import id.walt.nftkit.services.*
+import id.walt.nftkit.tokenownersquery.TokenOwnersDataResponse
+import id.walt.nftkit.utilis.Common
+import io.javalin.http.Context
+import io.javalin.plugin.openapi.dsl.document
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+
+
+object AlgorandNftController{
+
+    private const val TAG = "Algorand Blockchain: Non-fungible tokens(NFTs)"
+    fun accountCreation(ctx : Context){
+        val result = AlgorandNftService.createAccount()
+        ctx.json(result)
+    }
+
+    fun accountCreationDocs() = document().operation {
+        it.summary("Create Algorand Account").operationId("CreateAlgorandAccount").addTagsItem("Algorand Blockchain: Non-fungible tokens(NFTs)")
+    }.json<AlgorandAccount>(200.toString()) {
+        it.description("Algorand Account")
+    }
+
+
+    fun assetCreation(ctx : Context){
+        val result = AlgorandNftService.createAssetArc3(ctx.pathParam("assetName"), ctx.pathParam("assetUnitName"), ctx.pathParam("url"))
+        ctx.json(result)
+    }
+
+    fun assetCreationDocs() = document().operation {
+        it.summary("Create Algorand Asset").operationId("CreateAlgorandAsset").addTagsItem("Algorand Blockchain: Non-fungible tokens(NFTs)")
+    }.json<AlgodResponse>(200.toString()) {
+        it.description("Algorand Asset")
+    }
+
+
+
+
+
+    fun fetchToken(ctx: Context){
+        val chain =ctx.pathParam("chain")
+        val asset  = ctx.pathParam("assetId")
+        val response = AlgorandNftService.getToken(
+            asset.toLong(),
+            Common.getAlgorandChain(chain.uppercase())
+        )
+        ctx.json(response)
+    }
+    fun fetchTokenDocs()= document().operation {
+        it.summary("Fetching Token")
+            .operationId("fetchToken")
+            .addTagsItem(TAG)}
+        .pathParam<String>("chain") {
+            it.schema<AlgorandChain>{}}
+        .pathParam<String>("assetId"){}
+        .json<AlgorandToken>("200"){
+            it.description("Fetched token")
+        }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    fun fetchAssetMetadata(ctx: Context){
+        val chain =ctx.pathParam("chain")
+        val asset  = ctx.pathParam("assetId")
+        val response = AlgorandNftService.getAssetMeatadata(
+            asset.toLong(),
+            Common.getAlgorandChain(chain.uppercase())
+        )
+        ctx.json(response)
+    }
+    fun fetchAssetMetadataDocs()= document().operation {
+        it.summary("Fetching token parametrs ")
+            .operationId("fetchAlgornadAssets")
+            .addTagsItem(TAG)}
+        .pathParam<String>("chain") {
+            it.schema<AlgorandChain>{}}
+        .pathParam<String>("assetId"){}
+        .json<Asset>("200"){
+            it.description("Fetched token parameteres")
+        }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    fun fetchAccountAssets(ctx: Context){
+        val chain = ctx.pathParam("chain")
+        val address = ctx.pathParam("address")
+        val response = AlgorandNftService.getAccountAssets(address, Common.getAlgorandChain(chain.uppercase()))
+        ctx.json(response)
+    }
+    fun fetchAccountAssetsDocs()= document().operation {
+        it.summary("Fetching account tokens ")
+            .operationId("fetchAccountAssets")
+            .addTagsItem(TAG)}
+        .pathParam<String>("chain") {
+            it.schema<AlgorandChain>{}}
+        .pathParam<String>("address"){}
+        .json<AssetHoldingsResponse>("200"){
+            it.description("Fetched Tokens")
+        }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    fun fetchNftMetadata(ctx: Context){
+        val chain =ctx.pathParam("chain")
+        val asset  = ctx.pathParam("assetId")
+        val result = AlgorandNftService.getNftMetadata(asset.toLong(), Common.getAlgorandChain(chain.uppercase()) )
+        ctx.result(Json.encodeToString(result))
+
+    }
+    fun fetchNftMetadataDocs()= document().operation {
+        it.summary("Fetching NFT metadata ")
+            .operationId("fetchAlgornadNfts")
+            .addTagsItem(TAG)}
+        .pathParam<String>("chain") {
+            it.schema<AlgorandChain>{}}
+        .pathParam<String>("assetId"){}
+        .json<AlgoNftMetadata>("200"){
+            it.description("Fetched NFT metadata")
+        }
+}

src/main/kotlin/id/walt/nftkit/rest/NftKitApi.kt

@@ -279,6 +279,34 @@ object NftKitApi {
 
                             )
                         }
+
+                        path("Algorand"){
+
+                            post("account/create/",
+                                documented(AlgorandNftController.accountCreationDocs(), AlgorandNftController::accountCreation)
+                            )
+                            post("asset/create/{assetName}/{assetUnitName}/{url}/",
+                                documented(AlgorandNftController.assetCreationDocs(), AlgorandNftController::assetCreation)
+                            )
+
+                            get(
+                                "chain/{chain}/asset/{assetId}",
+                                documented(AlgorandNftController.fetchTokenDocs(), AlgorandNftController::fetchToken)
+                            )
+                            get(
+                                "chain/{chain}/asset/{assetId}/params",
+                                documented(AlgorandNftController.fetchAssetMetadataDocs(), AlgorandNftController::fetchAssetMetadata)
+                            )
+                            get(
+                                "chain/{chain}/asset/{assetId}/metadata",
+                                documented(AlgorandNftController.fetchNftMetadataDocs(), AlgorandNftController::fetchNftMetadata)
+                            )
+                            get(
+                                "chain/{chain}/assets/account/{address}/",
+                                documented(AlgorandNftController.fetchAccountAssetsDocs(), AlgorandNftController::fetchAccountAssets)
+                            )
+
+                        }
                     }
                     path("nft/verifier") {
                         get(

src/main/kotlin/id/walt/nftkit/rest/TezosNftController.kt

@@ -101,8 +101,7 @@ object TezosNftController {
         val chain = ctx.pathParam("chain")
         val contractAddress = ctx.pathParam("contractAddress")
         val tokenId = ctx.pathParam("tokenId")
-        val result =
-            TezosNftService.getNftTezosMetadata(Common.getTezosChain(chain.uppercase()), contractAddress, tokenId)
+        val result = TezosNftService.getNftTezosMetadata(Common.getTezosChain(chain.uppercase()), contractAddress, tokenId)
         result?.let {
             ctx.json(
                 it
@@ -140,4 +139,4 @@ object TezosNftController {
     }
 
 
-}
+}