Top 10 Examples of "ipns in functional component" in JavaScript
Dive into secure and efficient coding practices with our curated list of the top 10 examples showcasing 'ipns' in functional components in JavaScript. Our advanced machine learning engine meticulously scans each line of code, cross-referencing millions of open source libraries to ensure your implementation is not just functional, but also robust and secure. Elevate your React applications to new heights by mastering the art of handling side effects, API calls, and asynchronous operations with confidence and precision.
// Wait until a peer subscribes a topic
const waitForPeerToSubscribe = async (node, topic) => {
for (let i = 0; i < 5; i++) {
const res = await node.pubsub.peers(topic)
if (res && res.length) {
return
}
await delay(2000)
}
throw new Error(`Could not find subscription for topic ${topic}`)
}
const keys = ipns.getIdKeys(fromB58String(idA.id))
const topic = `${namespace}${base64url.encode(keys.routingKey.toBuffer())}`
await expect(nodeB.name.resolve(idA.id))
.to.eventually.be.rejected()
.and.to.have.property('code', 'ERR_NO_RECORD_FOUND')
await waitForPeerToSubscribe(nodeA, topic)
await nodeB.pubsub.subscribe(topic, checkMessage)
await nodeA.name.publish(ipfsRef, { resolve: false })
await waitFor(alreadySubscribed)
await delay(1000) // guarantee record is written
const res = await nodeB.name.resolve(idA.id)
expect(res).to.equal(ipfsRef)
})const topic = `${namespace}${base64url.encode(keys.routingKey.toBuffer())}`
await nodeB.pubsub.subscribe(topic, checkMessage)
await nodeA.name.publish(ipfsRef, { resolve: false, key: testAccountName })
await waitFor(alreadySubscribed)
const messageKey = await promisify(peerId.createFromPubKey)(publishedMessage.key)
const pubKeyPeerId = await promisify(peerId.createFromPubKey)(publishedMessageData.pubKey)
expect(pubKeyPeerId.toB58String()).not.to.equal(messageKey.toB58String())
expect(pubKeyPeerId.toB58String()).to.equal(testAccount.id)
expect(publishedMessage.from).to.equal(idA.id)
expect(messageKey.toB58String()).to.equal(idA.id)
expect(publishedMessageDataValue).to.equal(ipfsRef)
// Verify the signature
await ipns.validate(pubKeyPeerId._pubKey, publishedMessageData)
})
})async _getPreviousValue (peerId) {
if (!(PeerId.isPeerId(peerId))) {
throw errcode(new Error('invalid peer ID'), 'ERR_INVALID_PEER_ID')
}
try {
const dsVal = await this._datastore.get(ipns.getLocalKey(peerId.id))
if (!Buffer.isBuffer(dsVal)) {
throw errcode(new Error("found ipns record that we couldn't process"), 'ERR_INVALID_IPNS_RECORD')
}
// unmarshal data
try {
const record = ipns.unmarshal(dsVal)
return record.value
} catch (err) {
log.error(err)
throw errcode(new Error('found ipns record that we couldn\'t convert to a value'), 'ERR_INVALID_IPNS_RECORD')
}
} catch (err) {
// error handling
// no need to republish
if (err && err.notFound) {
throw errcode(new Error(`no previous entry for record with id: ${peerId.id}`), 'ERR_NO_ENTRY_FOUND')
}
throw err
}
}try {
record = await this._routing.get(routingKey.toBuffer())
} catch (err) {
log.error(err)
if (err.code === ERR_NOT_FOUND) {
throw errcode(new Error(`record requested for ${name} was not found in the network`), 'ERR_NO_RECORD_FOUND')
}
throw errcode(new Error(`unexpected error getting the ipns record ${peerId.id}`), 'ERR_UNEXPECTED_ERROR_GETTING_RECORD')
}
// IPNS entry
let ipnsEntry
try {
ipnsEntry = ipns.unmarshal(record)
} catch (err) {
log.error(err)
throw errcode(new Error('found ipns record that we couldn\'t convert to a value'), 'ERR_INVALID_RECORD_RECEIVED')
}
// if the record has a public key validate it
if (ipnsEntry.pubKey) {
return this._validateRecord(peerId, ipnsEntry)
}
// Otherwise, try to get the public key from routing
let pubKey
try {
pubKey = await this._routing.get(routingKey.toBuffer())
} catch (err) {async _resolveName (name) {
const peerId = PeerId.createFromBytes(new CID(name).multihash) // TODO: change to `PeerId.createFromCID` when https://github.com/libp2p/js-peer-id/pull/105 lands and js-ipfs switched to async peer-id lib
const { routingKey } = ipns.getIdKeys(peerId.toBytes())
let record
try {
record = await this._routing.get(routingKey.toBuffer())
} catch (err) {
log.error(err)
if (err.code === ERR_NOT_FOUND) {
throw errcode(new Error(`record requested for ${name} was not found in the network`), 'ERR_NO_RECORD_FOUND')
}
throw errcode(new Error(`unexpected error getting the ipns record ${peerId.id}`), 'ERR_UNEXPECTED_ERROR_GETTING_RECORD')
}
// IPNS entry
let ipnsEntryasync _putRecordToRouting (record, peerId) {
if (!(PeerId.isPeerId(peerId))) {
const errMsg = 'peerId received is not valid'
log.error(errMsg)
throw errcode(new Error(errMsg), 'ERR_INVALID_PEER_ID')
}
const publicKey = peerId._pubKey
const embedPublicKeyRecord = await ipns.embedPublicKey(publicKey, record)
const keys = ipns.getIdKeys(peerId.toBytes())
await this._publishEntry(keys.routingKey, embedPublicKeyRecord || record, peerId)
// Publish the public key to support old go-ipfs nodes that are looking for it in the routing
// We will be able to deprecate this part in the future, since the public keys will be only
// in IPNS record and the peerId.
await this._publishPublicKey(keys.routingPubKey, publicKey)
return embedPublicKeyRecord || record
}return this._unmarshalData(dsVal)
} catch (err) {
if (err.code !== ERR_NOT_FOUND) {
const errMsg = `unexpected error getting the ipns record ${peerId.id} from datastore`
log.error(errMsg)
throw errcode(new Error(errMsg), 'ERR_UNEXPECTED_DATASTORE_RESPONSE')
}
if (!checkRouting) {
throw errcode(err)
}
// Try to get from routing
try {
const keys = ipns.getIdKeys(peerId.toBytes())
const res = await this._routing.get(keys.routingKey.toBuffer())
// unmarshal data
return this._unmarshalData(res)
} catch (err) {
log.error(err)
throw err
}
}
}entryData = await ipns.create(privKey, value, seqNumber, validity)
} catch (err) {
const errMsg = `ipns record for ${value} could not be created`
log.error(err)
throw errcode(new Error(errMsg), 'ERR_CREATING_IPNS_RECORD')
}
// TODO IMPROVEMENT - set ttl (still experimental feature for go)
try {
// Marshal record
const data = ipns.marshal(entryData)
// Store the new record
await this._datastore.put(ipns.getLocalKey(peerId.id), data)
log(`ipns record for ${value} was stored in the datastore`)
return entryData
} catch (err) {
const errMsg = `ipns record for ${value} could not be stored in the datastore`
log.error(errMsg)
throw errcode(new Error(errMsg), 'ERR_STORING_IN_DATASTORE')
}
}
}async _getPublished (peerId, options) {
if (!(PeerId.isPeerId(peerId))) {
const errMsg = 'peerId received is not valid'
log.error(errMsg)
throw errcode(new Error(errMsg), 'ERR_INVALID_PEER_ID')
}
options = options || {}
const checkRouting = options.checkRouting !== false
try {
const dsVal = await this._datastore.get(ipns.getLocalKey(peerId.id))
// unmarshal data
return this._unmarshalData(dsVal)
} catch (err) {
if (err.code !== ERR_NOT_FOUND) {
const errMsg = `unexpected error getting the ipns record ${peerId.id} from datastore`
log.error(errMsg)
throw errcode(new Error(errMsg), 'ERR_UNEXPECTED_DATASTORE_RESPONSE')
}
if (!checkRouting) {
throw errcode(err)
}
// Try to get from routingasync _getPreviousValue (peerId) {
if (!(PeerId.isPeerId(peerId))) {
throw errcode(new Error('invalid peer ID'), 'ERR_INVALID_PEER_ID')
}
try {
const dsVal = await this._datastore.get(ipns.getLocalKey(peerId.id))
if (!Buffer.isBuffer(dsVal)) {
throw errcode(new Error("found ipns record that we couldn't process"), 'ERR_INVALID_IPNS_RECORD')
}
// unmarshal data
try {
const record = ipns.unmarshal(dsVal)
return record.value
} catch (err) {
log.error(err)
throw errcode(new Error('found ipns record that we couldn\'t convert to a value'), 'ERR_INVALID_IPNS_RECORD')
}
} catch (err) {
// error handling