A First Look at Dash

import Dash from "dash"

const { NETWORK } = process.env

export const client = new Dash.Client({
  network: NETWORK,
  wallet: {
    mnemonic: null,
    offlineMode: true,
  },
})

import { client } from '../api/client.js'

async function dapiClientMethods() {
  try {
    const dapiClient = client.getDAPIClient().core

    console.log("\ngetBlockHash(1):", await dapiClient.getBlockHash(1))
    console.log("\ngetBestBlockHash():", await dapiClient.getBestBlockHash())
    console.log("\ngetBlockByHeight():", await dapiClient.getBlockByHeight(1))
  } catch (error) {
    console.error('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

dapiClientMethods()

import { client } from '../api/client.js'

async function createWallet() {
  try {
    const walletAccount = await client.getWalletAccount()
    const mnemonic = client.wallet.exportWallet()
    const { address } = walletAccount.getUnusedAddress()

    console.log("WALLET_ADDRESS=" + `"${address}"`)
    console.log("MNEMONIC=" + `"${mnemonic}"`)
  } catch (error) {
    console.error('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

createWallet()

import Dash from "dash"

const { NETWORK, MNEMONIC } = process.env

export const client = new Dash.Client({
  network: NETWORK,
  wallet: {
    mnemonic: MNEMONIC,
    unsafeOptions: {
      skipSynchronizationBeforeHeight: 990000,
    },
  },
})

import { client } from '../api/client.js'

async function createIdentity() {
  try {
    const identity = await client.platform.identities.register()
    console.log("IDENTITY_ID=" + `"${identity.toJSON().id}"`)
    console.log(`\nView on platform block explorer: https://platform-explorer.com/identity/${identity.toJSON().id}\n`)
  } catch (error) {
    console.error('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

createIdentity()

import { client } from '../api/client.js'

async function retrieveIdentities() {
  try {
    const walletAccount = await client.getWalletAccount()
    const identityIds = walletAccount.identities.getIdentityIds()
    console.log("\nRetrieved Identity IDs:\n" + JSON.stringify(identityIds, null, 2))

    for (const id of identityIds) {
      const identity = await client.platform.identities.get(id)
      console.log(`\nIdentity ID: ${id}`)
      console.log(`  - Balance: ${identity.balance}`)
    }
  } catch (error) {
    console.error('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

retrieveIdentities()

import { client } from '../api/client.js'

async function topupIdentities() {
  try {
    const walletAccount = await client.getWalletAccount()
    const identityIds = walletAccount.identities.getIdentityIds()

    for (const id of identityIds) {
      await client.platform.identities.topUp(id, 100000000)
      const identity = await client.platform.identities.get(id)
      console.log(`IDENTITY_CREDIT_BALANCE for ID ${id}: ${identity.balance}`)
    }
  } catch (error) {
    console.error('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

topupIdentities()

import { client } from '../api/client.js'

const { IDENTITY_ID, LABEL } = process.env

async function registerName() {
  try {
    const identity = await client.platform.identities.get(IDENTITY_ID)
    const dashUniqueIdentityId = await identity.getId()
    const nameRegistration = await client.platform.names.register(
      `${LABEL}.dash`, { dashUniqueIdentityId }, identity
    )
    console.log("LABEL=" + JSON.stringify(nameRegistration.toJSON().label))
    console.log(`\nView on block explorer: https://platform-explorer.com/document/${nameRegistration.toJSON().$id}\n`)
  } catch (error) {
    console.error("Something went wrong:\n", error)
  } finally {
    client.disconnect()
  }
}

registerName()

import { client } from '../api/client.js'

const { LABEL } = process.env

async function retrieveName() {
  try {
    const extendedDoc = await client.platform.names.resolve(`${LABEL}.dash`)
    const name = JSON.parse(JSON.stringify(extendedDoc))
    console.log(`\nResolved name object:\n\n`, name)
    console.log(`\nView on block explorer: https://platform-explorer.com/document/${name.$id}\n`)
  } catch (error) {
    console.error('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

retrieveName()

import { client } from '../api/client.js'

const { IDENTITY_ID } = process.env

const registerContract = async () => {
  try {
    const identity = await client.platform.identities.get(IDENTITY_ID)
    const contractDocuments = {
      note: {
        type: 'object',
        properties: { message: { type: 'string', position: 0 } },
        additionalProperties: false
      }
    }
    const contract = await client.platform.contracts.create(contractDocuments, identity)
    console.log("\nCONTRACT_ID=" + `"${contract.toJSON().id}"`)

    await client.platform.contracts.publish(contract, identity)
    console.log('\nContract registered:\n\n', contract.toJSON())
    console.log(`\nView on platform block explorer:\n\nhttps://platform-explorer.com/dataContract/${contract.toJSON().id}\n`)
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

registerContract()

import { client } from '../api/client.js'

const { CONTRACT_ID } = process.env

const retrieveContract = async () => {
  try {
    const contract = await client.platform.contracts.get(CONTRACT_ID)
    console.dir(contract.toJSON(), { depth: 5 })
    console.log(`\nView on platform block explorer:\n\nhttps://platform-explorer.com/dataContract/${contract.toJSON().id}\n`)
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

retrieveContract()

import { client } from '../api/client.js'

const { IDENTITY_ID, CONTRACT_ID } = process.env

const updateContract = async () => {
  try {
    const identity = await client.platform.identities.get(IDENTITY_ID)
    const existingDataContract = await client.platform.contracts.get(CONTRACT_ID)
    const documentSchema = existingDataContract.getDocumentSchema('note')

    documentSchema.properties.author = {
      type: 'string',
      position: 1
    }

    existingDataContract.setDocumentSchema('note', documentSchema)

    await client.platform.contracts.update(existingDataContract, identity)
    console.log('\nContract updated:\n\n', existingDataContract.toJSON())
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

updateContract()

import Dash from "dash"

const { NETWORK, MNEMONIC, CONTRACT_ID } = process.env

export const client = new Dash.Client({
  network: NETWORK,
  wallet: {
    mnemonic: MNEMONIC,
    unsafeOptions: {
      skipSynchronizationBeforeHeight: 990000,
    },
  },
  apps: {
    tutorialContract: {
      contractId: CONTRACT_ID,
    },
  },
})

import { client } from '../api/client.js'

const { IDENTITY_ID } = process.env

const submitNoteDocument = async () => {
  try {
    const identity = await client.platform.identities.get(IDENTITY_ID)
    const noteDocument = await client.platform.documents.create(
      'tutorialContract.note',
      identity,
      { message: `Hello from ajcwebdev @ ${new Date().toUTCString()}` },
    )
    await client.platform.documents.broadcast({
      create: [noteDocument],
      replace: [],
      delete: [],
    }, identity)
    console.log(`DOCUMENT_ID="${noteDocument.toJSON().$id}"`)
    console.log(noteDocument.toJSON())
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

submitNoteDocument()

import { client } from '../api/client.js'

const getDocuments = async () => {
  try {
    const documents = await client.platform.documents.get(
      'tutorialContract.note',
      { limit: 5 }
    )
    console.log('\nLast 5 messages:\n')
    documents.forEach(n => console.log(n.toJSON().message))
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

getDocuments()

import { client } from '../api/client.js'

const { IDENTITY_ID, DOCUMENT_ID } = process.env

const updateNoteDocument = async () => {
  try {
    const identity = await client.platform.identities.get(IDENTITY_ID)

    const [document] = await client.platform.documents.get(
      'tutorialContract.note',
      { where: [['$id', '==', DOCUMENT_ID]] },
    )

    document.set(
      'message',
      `Hello from ajcwebdev again @ ${new Date().toUTCString()}`
    )

    await client.platform.documents.broadcast({ replace: [document] }, identity)
    console.log('\nMessage: ', document.toJSON().message)
    console.log('\nDocument updated:\n\n', document.toJSON())
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

updateNoteDocument()

import { client } from '../api/client.js'

const { IDENTITY_ID, DOCUMENT_ID } = process.env

const deleteNoteDocument = async () => {
  try {
    const identity = await client.platform.identities.get(IDENTITY_ID)

    const [document] = await client.platform.documents.get(
      'tutorialContract.note',
      { where: [['$id', '==', DOCUMENT_ID]] },
    )

    await client.platform.documents.broadcast({ delete: [document] }, identity)
    console.log('Document deleted:\n', document.toJSON())
  } catch (e) {
    console.error('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

deleteNoteDocument()

import express from 'express'
import cors from 'cors'
import { client } from './client.js'

const app = express()
app.use(cors())

app.get('/name/:identityName', async (req, res) => {
  try {
    const name = req.params.identityName
    const result = await client.platform.names.resolve(`${name}.dash`)
    if (result !== null) {
      res.json(result.toJSON())
    } else {
      res.status(404).send(`No identity found with the name: ${name}.dash`)
    }
  } catch (error) {
    console.error(error)
    res.status(500).send('Something went wrong:\n' + error)
  }
})

const port = process.env.PORT || 3001

app.listen(port, () => {
  console.log("Running on localhost:", port)
})

process.on('SIGINT', async () => {
  console.log('Disconnecting Dash client...')
  await client.disconnect()
  process.exit(0)
})

const main = "flex flex-col items-center justify-between p-24"
const header = "text-3xl"
const pageContent = "z-10 max-w-5xl w-full items-center justify-between font-sans lg:flex"

export default function Home() {
  return (
    <main className={main}>
      <h1 className={header}>Next.js Dash Example</h1>
      <div className={pageContent}>
        <h2>Identity:</h2>
      </div>
    </main>
  )
}

"use client"

import { useEffect, useState } from 'react'

const main = "flex flex-col items-center justify-between p-24"
const header = "text-3xl"
const pageContent = "z-10 max-w-5xl w-full items-center justify-between font-sans lg:flex"

export default function Home() {
  const [blockchainData, setBlockchainData] = useState(null)
  useEffect(() => {
    fetch('http://localhost:3001/name/ajcwebdev')
      .then(response => response.json())
      .then(data => setBlockchainData(data))
  }, [])
  return (
    <main className={main}>
      <h1 className={header}>Next.js Dash Example</h1>
      <div className={pageContent}>
        <h2>Identity:</h2>
        <pre>
          {JSON.stringify(blockchainData, null, 2)}
        </pre>
      </div>
    </main>
  )
}

"use client"

import { useEffect, useState } from 'react'

const main = "flex flex-col items-center justify-between p-24"
const header = "text-3xl"
const pageContent = "z-10 max-w-5xl w-full items-center justify-between font-sans lg:flex"

export default function Home() {
  const [blockchainData, setBlockchainData] = useState()
  const [triggerFetch, setTriggerFetch] = useState(false)
  const [isLoading, setIsLoading] = useState(false)

  const fetchData = () => {
    setIsLoading(true) // Set loading to true when fetch begins
    fetch('http://localhost:3001/name/ajcwebdev')
      .then(response => response.json())
      .then(data => {
        setBlockchainData(data)
        setIsLoading(false) // Set loading to false when fetch completes
      })
  }

  useEffect(() => {
    if (triggerFetch) {
      fetchData()
      setTriggerFetch(false) // Reset trigger
    }
  }, [triggerFetch])
  return (
    <main className={main}>
      <h1 className={header}>Next.js Dash Example</h1>
      <div className={pageContent}>
        <h2>Identity:</h2>
        <button onClick={() => setTriggerFetch(true)}>
          Fetch Data
        </button>
        <pre>
          {isLoading
            ? 'Loading...'
            : JSON.stringify(blockchainData, null, 2)
          }
        </pre>
      </div>
    </main>
  )
}