A First Look at Dash

import Dash from "dash"

const { NETWORK } = process.env

export const client = new Dash.Client({
  network: NETWORK,
  // Picking a known good ip address can sometimes help reliability
  // Uncomment the next line if network is throwing errors
  // dapiAddresses: ["44.227.137.77:1443"],
  wallet: {
    offlineMode: true,
  },
})

export const log = console.log
export const err = console.error
export const dir = console.dir

export const platform = client.platform
export const wallet = client.wallet

import { log, err, client, wallet } from '../api/client.js'

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

    log("WALLET_ADDRESS=" + `"${address}"`)
    log("MNEMONIC=" + `"${mnemonic}"`)
  } catch (error) {
    err('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,
  // Picking a known good ip address can sometimes help reliability
  // Uncomment the next line if network is throwing errors
  // dapiAddresses: ["44.227.137.77:1443"],
  wallet: {
    mnemonic: MNEMONIC,
    unsafeOptions: {
      skipSynchronizationBeforeHeight: 990000,
    },
  },
})

export const log = console.log
export const err = console.error
export const dir = console.dir

export const platform = client.platform
export const wallet = client.wallet

import { log, err, client, platform } from '../api/client.js'

async function createIdentity() {
  try {
    const identity = await platform.identities.register()

    log("IDENTITY_ID=" + `"${identity.toJSON().id}"`)
    log(`\nView on platform block explorer: https://testnet.platform-explorer.com/identity/${identity.toJSON().id}\n`)
  } catch (error) {
    err('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

createIdentity()

import { log, err, client, platform } from '../api/client.js'

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

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

retrieveIdentities()

import { log, err, client, platform } from '../api/client.js'

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

    for (const id of identityIds) {
      await platform.identities.topUp(
        id,
        10000000
      )

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

topUpIdentities()

import { log, err, client, platform } from '../api/client.js'

const { IDENTITY_ID, LABEL } = process.env

async function registerName() {
  try {
    const identity = await platform.identities.get(IDENTITY_ID)
    const nameRegistration = await platform.names.register(
      `${LABEL}.dash`,
      { identity: IDENTITY_ID },
      identity
    )

    log("LABEL=" + JSON.stringify(nameRegistration.toJSON().label))
    log(`\nView on block explorer: https://testnet.platform-explorer.com/document/${nameRegistration.toJSON().$id}\n`)
  } catch (error) {
    err("Something went wrong:\n", error)
  } finally {
    client.disconnect()
  }
}

registerName()

import { log, err, client, platform } from '../api/client.js'

const { LABEL } = process.env

async function retrieveName() {
  try {
    const extendedDoc = await platform.names.resolve(`${LABEL}.dash`)
    const name = JSON.parse(JSON.stringify(extendedDoc))

    log(`\nResolved name object:\n\n`, name)
    log(`\nView on block explorer: https://testnet.platform-explorer.com/document/${name.$id}\n`)
  } catch (error) {
    err('Something went wrong:\n', error)
  } finally {
    client.disconnect()
  }
}

retrieveName()

import { log, err, client, platform } from '../api/client.js'

const { IDENTITY_ID } = process.env

const registerContract = async () => {
  try {
    const identity = await platform.identities.get(IDENTITY_ID)
    const contractDocuments = {
      note: {
        type: 'object',
        properties: { message: { type: 'string', position: 0 } },
        additionalProperties: false
      }
    }

    const contract = await platform.contracts.create(
      contractDocuments,
      identity
    )

    await platform.contracts.publish(
      contract,
      identity
    )
    log('\nContract registered:\n\n', JSON.stringify(contract, null, 2))
    log(`\nView on platform block explorer:\n\nhttps://testnet.platform-explorer.com/dataContract/${contract.toJSON().id}\n`)
    log("\nCONTRACT_ID=" + `"${contract.toJSON().id}"`)
  } catch (e) {
    err('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

registerContract()

import { log, err, dir, client, platform } from '../api/client.js'

const { CONTRACT_ID } = process.env

const retrieveContract = async () => {
  try {
    const contract = await platform.contracts.get(CONTRACT_ID)

    dir(contract.toJSON(), { depth: 5 })
    log(`\nView on platform block explorer:\n\nhttps://testnet.platform-explorer.com/dataContract/${contract.toJSON().id}\n`)
  } catch (e) {
    err('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

retrieveContract()

import { log, err, client, platform } from '../api/client.js'

const { IDENTITY_ID, CONTRACT_ID } = process.env

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

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

    originalContract.setDocumentSchema(
      'note',
      documentSchema
    )

    await platform.contracts.update(originalContract, identity)
    log('\nContract updated:\n\n', `${JSON.stringify(originalContract, null, 2)}`)
  } catch (e) {
    err('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,
  // Picking a known good ip address can sometimes help reliability
  // Uncomment the next line if network is throwing errors
  // dapiAddresses: ["44.227.137.77:1443"],
  wallet: {
    mnemonic: MNEMONIC,
    unsafeOptions: {
      skipSynchronizationBeforeHeight: 990000,
    },
  },
  apps: {
    tutorialContract: {
      contractId: CONTRACT_ID,
    },
  },
})

export const log = console.log
export const err = console.error
export const dir = console.dir

export const platform = client.platform
export const wallet = client.wallet

import { log, err, client, platform } from '../api/client.js'

const { IDENTITY_ID, LABEL } = process.env

const submitNoteDocument = async () => {
  try {
    const identity = await platform.identities.get(IDENTITY_ID)
    const noteDocument = await platform.documents.create(
      'tutorialContract.note',
      identity,
      { message: `Hello from ${LABEL} @ ${new Date().toUTCString()}` },
    )

    await platform.documents.broadcast(
      {
        create: [noteDocument],
        replace: [],
        delete: [],
      },
      identity
    )

    log(`${JSON.stringify(noteDocument, null, 2)}`)
    log(`DOCUMENT_ID="${noteDocument.toJSON().$id}"`)
  } catch (e) {
    err('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

submitNoteDocument()

import { log, err, client, platform } from '../api/client.js'

const getDocuments = async () => {
  try {
    const documents = await platform.documents.get(
      'tutorialContract.note',
      { limit: 5 }
    )
    log('\nLast 5 messages:\n')

    documents.forEach(
      n => log(n.toJSON().message)
    )
  } catch (e) {
    err('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

getDocuments()

import { log, err, client, platform } from '../api/client.js'

const { IDENTITY_ID, DOCUMENT_ID, LABEL } = process.env

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

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

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

    await platform.documents.broadcast(
      { replace: [document] },
      identity
    )

    log('\nMessage: ', document.toJSON().message)
    log('\nDocument updated:\n\n', `${JSON.stringify(document, null, 2)}`)
  } catch (e) {
    err('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

updateNoteDocument()

import { log, err, client, platform } from '../api/client.js'

const { IDENTITY_ID, DOCUMENT_ID } = process.env

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

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

    await platform.documents.broadcast(
      { delete: [document] },
      identity
    )

    log('Document deleted:\n', document.toJSON())
    log('Document deleted:\n', `${JSON.stringify(document, null, 2)}`)
  } catch (e) {
    err('Something went wrong:\n', e)
  } finally {
    client.disconnect()
  }
}

deleteNoteDocument()

import express from 'express'
import cors from 'cors'
import { log, err, client, platform } 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 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) {
    err(error)
    res.status(500).send('Something went wrong:\n' + error)
  }
})

const port = process.env.PORT || 3001

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

process.on('SIGINT', async () => {
  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/${process.env.NEXT_PUBLIC_LABEL}`)
      .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/${process.env.NEXT_PUBLIC_LABEL}`)
      .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>
  )
}