New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

ddeep-core

Package Overview
Dependencies
Maintainers
1
Versions
21
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

ddeep-core - npm Package Compare versions

Comparing version 1.0.9 to 1.1.0

bun.lockb
ddeep.config.ts
init/init.js
policies.config.ts
src/dup.ts
src/get.ts
src/ham.js
src/policies/builder.ts
src/policies/checker.ts
src/policies/classes_calssifier.ts
src/policies/processor.ts
src/policies/scanner.ts
src/policies/serve.ts
src/put.ts
src/serve.ts
src/smart_checker.js
src/storage/checkpoint.ts
src/storage/radisk.js
src/storage/radix.js
src/storage/radmigtmp.js
src/storage/read_graph.ts
src/storage/recover.ts
src/storage/store.ts
src/storage/yson.js
src/unsubscribe.ts

93

package.json
{
"name": "ddeep-core",
"version": "1.0.9",
"description": "Decentralized real-time peer-to-peer data network",
"author": {
"name": "Kais Radwan",
"email": "kais.radwan.personal@gmail.com",
"url": "https://matrix.to/#/@multineon:gitter.im"
},
"engines": {
"node": ">=16.13.0 || >=18.0.0"
},
"scripts": {
"build-start": "./node_modules/.bin/esbuild dev/serve.js --bundle --outfile=dist/build.js --platform=node && node ./dist/build.js",
"start": "node ./dist/build.js",
"init": "node ./init/init.js",
"build": "./node_modules/.bin/esbuild dev/serve.js --bundle --outfile=dist/build.js --platform=node",
"bytenode-build": "bytenode --compile ./dist/build.js",
"bytenode-start": "bytenode ./dist/build.jsc"
},
"bin": {
"ddeep-init": "./lib/init/init.js"
},
"main": "./dist/build.js",
"preferGlobal": true,
"devDependencies": {
"@types/node": "^20.7.1",
"benchmark": "^2.1.4",
"tsc": "^2.0.4",
"typescript": "^5.2.2"
},
"dependencies": {
"@fastify/static": "^6.11.2",
"@fastify/websocket": "^8.2.0",
"@huggingface/inference": "^2.6.1",
"bytenode": "^1.5.1",
"colors": "^1.4.0",
"esbuild": "^0.19.4",
"fastify": "^4.23.2"
},
"keywords": [
"decentralized",
"realtime",
"synchronization",
"database",
"peer-to-peer",
"websockets",
"P2P",
"distributed"
],
"bugs": {
"url": "https://matrix.to/#/@multineon:gitter.im"
},
"license": "(MIT OR Zlib OR Apache-2.0)"
"name": "ddeep-core",
"version": "1.1.0",
"scripts": {
"start": "bun ./src/serve",
"build": "bun build --outdir=dist ./src/serve.ts"
},
"bin": {
"ddeep-init": "./init/init.js"
},
"preferGlobal": true,
"keywords": [
"decentralized",
"realtime",
"synchronization",
"database",
"peer-to-peer",
"websocket",
"P2P",
"distributed",
"bun",
"network"
],
"bugs": {
"url": "https://matrix.to/#/@multineon:gitter.im"
},
"license": "(MIT OR Zlib OR Apache-2.0)",
"devDependencies": {
"bun-types": "latest"
},
"peerDependencies": {
"typescript": "^5.0.0"
},
"dependencies": {
"@huggingface/inference": "^2.6.4"
},
"author": {
"name": "Kais Radwan",
"email": "kais.radwan.personal@gmail.com",
"url": "https://matrix.to/#/@multineon:gitter.im"
}
}

473

README.md

@@ -1,6 +0,5 @@

<div align="center">
<img align="center" src="https://opencollective-production.s3.us-west-1.amazonaws.com/account-long-description/dedb8939-f88e-4099-8d41-8680f0a67ef3/ddeep_big.png" height="200px" />
</div>
<br>
<br>
<h1 align="center">ddeep core</h1>
<p align="center">Decentralized real-time peer-to-peer data network</p>

@@ -10,11 +9,7 @@

![Static Badge](https://img.shields.io/badge/alpha_release-current?style=flat-square&color=slateblue)
![NPM Downloads](https://img.shields.io/npm/dm/ddeep-core?style=flat-square)
![NPM License](https://img.shields.io/npm/l/ddeep-core?style=flat-square)
![GitHub issues](https://img.shields.io/github/issues/kais-radwan/ddeep-core?style=flat-square)
![typescript version](https://img.shields.io/npm/dependency-version/ddeep-core/dev/typescript?style=flat-square)
![esbuild version](https://img.shields.io/npm/dependency-version/ddeep-core/esbuild?style=flat-square)
![Scrutinizer build](https://img.shields.io/scrutinizer/build/g/kais-radwan/ddeep-core/main?style=flat-square)
![code quality](https://img.shields.io/scrutinizer/quality/g/kais-radwan/ddeep-core/main?style=flat-square)
[![Socket Badge](https://socket.dev/api/badge/npm/package/ddeep-core?style=flat-square)](https://socket.dev/npm/package/ddeep-core)
[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=kais-radwan_ddeep-core&metric=bugs)](https://sonarcloud.io/summary/new_code?id=kais-radwan_ddeep-core)
[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=kais-radwan_ddeep-core&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=kais-radwan_ddeep-core)
[![Static Badge](https://img.shields.io/badge/chat-on_matrix-lightgreen?style=flat-square)](https://matrix.to/#/@multineon:gitter.im)

@@ -24,234 +19,183 @@

> This is an alpha version !
<br>
<img src="https://github.com/kais-radwan/ddeep-core/blob/development/dev/assets/core_terminal.png?raw=true" style="border-radius: 10px;" />
## Table of contents
Decentralized real-time peer-to-peer data core, used to save and sync decentralized graph data across connected peers, with features like:
- [Table of contents](#table-of-contents)
- [What is ddeep-core ?](#what-is-ddeep-core)
- [Install](#install)
- [Using npm](#using-npm)
- [Using Github](#using-github)
- [Using Docker](#using-docker)
- [Configurations](#configurations)
- [Cloud hosted](#cloud-hosted)
- [Policies](#policies)
- [Schema](#schema)
- [Check policies](#check-policies)
- [Smart policies (AI-powered)](#smart-policies)
- [Restort checkpoints](#restore-checkpoints)
- [Decentralized world](#decentralized-world)
- [Development](#development)
- [Contact me](#contact-me)
- Persistent data storage with recovery checkpoints
## What is ddeep-core ?
- Scoped and AI-powered data policies
> **ddeep-core is under development**. We are doing our best to reach a stable stage with this project, and please nore that ddeep-core is built using [Bun](https://github.com/oven-sh/bun), a project that's also under development.
- Real-time low latency connections
ddeep-core is a real-time back-end environment to run a decentralized peer-relay or what we call a `core` to sync and save decentralized graph data.
- Security features like IP whitelists, data policies, smart listeners so one device can't overload the core with connections
ddeep-core uses a publish-subscribe approach, and ships with a lot of features such as policies (checkers and AI-powered), persistent storage, data recovery checkpoints, and more...
- Command-line interactive interface to manage your network
You can run `ddeep-core` as a back-end peer-relay for your [Gun](https://www.npmjs.com/package/gun) project, and soon we'll be releasing a client library.
- `ddeep-core` works perfectly with Gun JS.
## Install
## Installation
First you need to **install Bun** if haven't already, you can use `npm install -g bun` to install Bun globally, or navigate to [Bun's website](https://bun.sh/).
We recommend you clone this repository and run `npm install` and then `npm start` to start ddeep-core.
> Use bun v1.0.7
Using npm, you can install ddeep-core globally:
### Using npm
> Use `sudo` if you get a permission error.
Install ddeep-core globally:
```bash
npm install -g ddeep-core
```
Now create a directory for your project and run:
```bash
ddeep-init
```
This will give you a complete ready-to-go environment, you can run `npm start` to start your network.
## Table of contents
Now run this in your working directory (has to be empty):
- [Installation](#installation)
- [Table of contents](#table-of-contents)
- [Getting started](#getting-started)
- [node \& npm](#node--npm)
- [docker](#docker)
- [build](#build)
- [Alpha](#alpha)
- [Configurations](#configurations)
- [Policies](#policies)
- [Add policies](#add-policies)
- [Schema](#schema)
- [Check policies](#check-policies)
- [Usage](#usage)
- [Smart policies](#smart-policies)
- [HuggingFace token](#huggingface-token)
- [Usage](#usage-1)
- [`smart_check` extension](#smart_check-extension)
- [Extensions](#extensions)
- [Add extensions](#add-extensions)
- [Schema](#schema-1)
- [Write your extensions](#write-your-extensions)
- [Use your extensions](#use-your-extensions)
- [Restore checkpoints](#restore-checkpoints)
- [Infrastructure](#infrastructure)
- [Communications](#communications)
- [CRDT](#crdt)
- [Storage](#storage)
- [Policies](#policies-1)
- [Check policies](#check-policies-1)
- [AI-powered policies](#ai-powered-policies)
- [Decentralized world](#decentralized-world)
- [Development](#development)
- [`dev` directory](#dev-directory)
- [License](#license)
- [NOTICE](#notice)
- [Thanks](#thanks)
- [The idea of ddeep-core](#the-idea-of-ddeep-core)
- [Ddeep ecosystem](#ddeep-ecosystem)
- [Gun](#gun)
- [Contact us](#contact-us)
## Getting started
### node & bytenode
To start your network using node, just run:
```bash
npm start
ddeep-init
```
or using bytenode:
Install the dependencies:
```bash
node start-bytenode
bun install
```
### docker
You can run ddeep-code in a [Docker](docker.com) container, you can pull the image from Docker hub:
and now start it:
```bash
docker pull multineon/ddeep-core
bun start
```
or build it from the source (recommended) :
```bash
docker build -t ddeep-core .
```
and now you can run ddeep-core as a docker container:
```bash
docker run -d ddeep-core
```
### build
### Using Github
To build your core again (needed after updating configurations, policies, and extensions):
Clone this repository:
```bash
npm run build
git clone https://github.com/kais-radwan/ddeep-core
```
or using bytenode:
Now install then dependencies:
```bash
npm run bytenode-build
bun install
```
or simply do this:
and start it:
```bash
npm run build-start
bun start
```
### Using Docker
to build your new configurations and start the server.
> Use `sudo` if you get a permission error using Docker.
Currently, everytime you make a change on your configurations, policies, extensions, or code, you need to build ddeep-core again, thanks to [esbuild](https://www.npmjs.com/package/esbuild) the build will usually be ready in under one second.
First install `ddeep-core` from npm or Github as described above, and run:
in coming versions this won't be the case and you won't need to build the code after every change.
```bash
docker build -t ddeep-core .
```
### Alpha
and now run it:
This project is still in `alpha testing` and in its early stages, so we are testing possible issues and bugs, if you face any issue please contact us or report it on Github.
```bash
docker run -d ddeep-core
```
## Configurations
in the root directory of your project, you'll find a config file called `ddeep.config.js` where all your configurations live, the default file content should look like this:
> You need to build the code using `npm run build` after everytime you update your configurations.
> Written in Typescript
in the `ddeep.config.js` you'll find comments explaining what every option does, and this is an example of the all default options:
Your core configurations are defined in the `ddeep.config.ts` found in your working directory, everything is explained with comments in the file itself.
```javascript
module.exports = {
## Cloud hosted
"storage": false,
If you are willing to run `ddeep-core` using a cloud hosting service (like [FL0](https://www.fl0.com/)), we recommend you fork this repository, edit the configurations file, and then deploy it.
"port": 9999,
anyway we recommend you check the default options in the `ddeep.config.ts` file, and if it's okay for you just use this repository to deploy your core.
"whitelist": [],
> `ddeep-core` will listen on port `3000` by default.
"hf": null,
## Policies
"checkpoint": null,
Policies are used to control access to data by applying conditions to specific nodes in the graph network.
"reset_graph": null,
You can add your policies in the `policies.config.ts` file, the default policies file should look something like this:
"reset_listeners": 6000000
```typescript
import { Policy } from './src/policies/builder';
}
```
let policies:Array<Policy> = [
## Interactive interface
// Your policies go here
When you start `ddeepc-core` it opens a command-line interface where you can manage your network, let's see available commands:
];
- `list peers`: lists all connected peers
export default policies;
```
- `list listeners`: lists graph listeners and the peers listening to them
### Schema
- `peer PEER_ID`: shows a peer info
let's first discover the schema of a policy in ddeep:
- `clear`: clears the terminal
```typescript
{
type: 'check' | 'smart',
operations: Array<'get', 'put'>,
graph: string,
check: Function: Boolean
}
```
- `clear peers`: clears all listening peers
- **type**: There are two types of policies, check policies and smart policies.
- `clear graph`: clears the cached graph data
- **operations**: Defines the data operations the policy is applied on, can be one of `get` when reading data, or `put` when writing data.
- `clear listeners`: clears all the listeners
- **graph**: the graph property accept a string of nodes the policies is applied to. if you apply a policy to people it's applied to all nodes under people, but if you apply a policy to people/kais the policy will only be applied to the node kais under people, and so on.
- `info`: shows the configurations info
- **check**: A function that returns a `Boolean` (`true` or `false`), if returns `true` the data operation will be performed, otherwise it will be ignored.
- `run CODE`: executes a nodeJS code inside the code's process
### Check policies
- `exec CODE`: executes a command in your operating system (tested with Linux)
Check policies are based on the check function, if the function returns true the access to the data will be granted and if it returns false the data access will be denied.
## Policies
let's see a simple example:
### Add policies
```typescript
import { Policy } from './src/policies/builder';
You can add policies to the `policies.config.js` file in the root directory of your project.
let policies:Array<Policy> = [
> You need to build the code using `npm run build` after everytime you configure your policies.
{
type: 'check',
operations: ['put'],
graph: 'people/kais',
### Schema
check: function (data: any): Boolean {
return (data?.name) ? true : false;
}
let's first discover a policy schema in Ddeep:
}
```javascript
POLICY(
type: 'check'|'smart',
operations: ['get', 'put'],
graph: string,
callback: Function // return true or false
)
```
There are two types of policies, check policies and smart policies, so let's discover how every policy works.
];
the `graph` property accept a string of nodes the policies is applied to. if you apply a policy to `people` it's applied to all nodes under `people`, but if you apply a policy to `people/kais` the policy will only be applied to the node `kais` under `people`, and so on.
### Check policies
Check policies are based on the check function, if the function returns `true` the access to the data will be granted and if it returns `false` the data access will be denied.
#### Usage
let's see a simple example:
```javascript
module.exports = [
POLICY(
'check', ['put'], 'people/kais',
(data) => {
return (data.name) ? true : false;
}
)
]
export default policies;
```
this policy will be applied to `put` operations to the node `kais` under `people` and it checks if the data we are putting have a `name` or not, if it does, the data operation will be granted and the data will be added otherwise the operation will be cancelled.
this policy will be applied to put operations to the node kais under people and it checks if the data we are putting have a name or not, if it does, the data operation will be granted and the data will be added otherwise the operation will be cancelled.
the `data` argument passed to the checking function contains the data being putted if the operation is `put`, and the data is being `getted` if the operation is `get`.
the data argument passed to the checking function contains the data being putted if the operation is put, and the data is being getted if the operation is get.
what matters is that the checking function has to return `true` or `false`, if returned `true` the opeartion will be processed, and if returned `false` the opeartion will be ignored.
what matters is that the checking function has to return true or false, if returned true the opeartion will be processed, and if returned false the opeartion will be ignored.

@@ -261,54 +205,54 @@ for example this is also a valid `check()` policy function:

```javascript
(data) => {
if (data.plan === "pro") {return true};
if (data.plan !== "pro") {return false};
function (data) {
if (data.plan === 'pro') {
return true;
} else {
return false;
}
}
```
you have full customizability to build your own check functions and policies.
so you have the freedom to build your own `check` functions and policies.
### Smart policies
> WARNING: the text classification model is giving poor classes scores and is not acurate, we are currently working on a fix for this
> WARNING: Smart policies's AI is giving bad results in some cases, has some bugs, and causing latency so be careful using it
> NOTICE: You need to add your HuggingFace token to your `ddeep.config.ts` file to avoid bad rate limits
Smart policies uses AI classification to classify the inputs and gives an object of classes with a score from 0.0 to 1.0 for every class or emotion as 1.0 is the highest score.
#### HuggingFace token
First of all we recommend you add your [HuggingFace token](https://huggingface.co/docs/hub/security-tokens) to your `ddeep.config.js` so you don't suffer from hard rate limits.
the classes generated will be passed to the `check` function, and you can check if a class is more than a certain value or less than a certain value easily, let's see an example:
#### Usage
You can check if a class is more than a certain value or less than a certain value, It's super easy let's see the example below:
```typescript
import { Policy } from './src/policies/builder';
import smartChecker from './src/smart_checker';
```javascript
module.exports = [
let policies:Array<Policy> = [
POLICY(
'smart', ['get', 'put'], 'posts',
(classes) => {
var smart_check = extensions.load('smart_check');
{
type: 'smart',
operations: ['get', 'put'],
graph: 'posts',
return smart_check(classes, [
[ "anger", "<0.5", true ],
[ "anger", ">0.5", false ]
]);
check: function (classes): Boolean {
return smartChecker(classes, [
[ "anger", "<0.5", true ],
[ "anger", ">0.5", false ]
]);
}
}
)
];
]
export default policies;
```
the policy above is applied to all nodes under `posts` and it blocks all data that contains angry inputs from being added or read.
the policy above is applied to all nodes under posts and it blocks all data that contains angry inputs from being added or read.
#### `smart_check` extension
with smart policies you need to use the `smartChecker` function to check the classes and return true or false, this is how it's used:
with smart policies you need to use `smart_check` extension to check the classes and return `true` or `false`.
the extension can be loaded using `extensions.load` and it's imported to your policies by default, this is how `smart_check` is used:
```javascript
var smartCheck = extensions.load('smart_check');
return smartCheck(classes, [
```typescript
return smartChecker(classes, [
[class: string, condition: string, return: true|false]

@@ -318,118 +262,38 @@ ])

- **Classes**: passed to the policy's function if the policy type is set to `smart` instead of the data in `check policies`.
- **Class**: have to be a valid class name.
- Classes: passed to the policy's function if the policy type is set to smart instead of the data in check policies.
- **Condition**: a string that starts with an operator and then a value to check if the class value apply to the condition. valid opeartors:
- `>` the class value is greater than the given value. example: `">0.3"`.
- `<` the class value is less than the given value. example: `"<0.7"`.
- Class: have to be a valid class name.
- **Return**: if the condition is applied, the check will return the value if the `return`.
- Condition: a string that starts with an operator and then a value to check if the class value apply to the condition. valid opeartors:
## Extensions
- `>` the class value is greater than the given value. example: ">0.3".
You can use extensions to expand the functionality of ddeep-core easily with full control, real-time listeners, and more...
- `<` the class value is less than the given value. example: "<0.7".
### Add extensions
- Return: if the condition is applied, the check will return the value if the return.
you add your extensions to the `extensions.config.js` found in the root directory of your project.
> You need to build the code using `npm run build` after everytime you configure your extensions.
## Restore checkpoints
### Schema
If you are using persistent storage, you can setup a checkpoint in the `ddeep.config.ts` so the system will create a restore checkpoint based on the options you give it. (more explained in the `ddeep.config.ts` file itself).
```json
{
"name": string,
"callback": Function
}
```
Now to recover data from a restore point, you need to run this:
### Write your extensions
```javascript
module.exports = [
{
name: 'object-keys',
callback: (obj) => {
return (typeof obj === 'object') ? Object.keys(obj) : null;
}
}
]
```
This is just a very simple extension that returns the keys in a data object. this extension might not be useful but it's just an example to show you how to write your own extensions.
### Use your extensions
Now you can use your extension in your policies or any other file using `extensions.load(extension_name)`. example:
```javascript
var get_object_keys = extensions.load('object-keys');
```
`extensions` is imported by default to your policies but if you want to use your extension in other files, you can require it:
```javascript
var extensions = require('./lib/ext/require');
```
## Whitelisted IPs
in the `ddeep.config.js` you can add a list of IP adresses (of peers, servers, or websites) that are able to connect to your core or server.
this can help you prevent cross-site connections to your core, if the list in empty this option will be ignored.
## Restore checkpoints
If you are using persistent storage, you can setup a checkpoint in the `ddeep.config.js` so the system will create a restore checkpoint based on the options you give it. (more explained in the `ddeep.config.js` file itself).
Now to load data from a restore point, you need to run this:
```bash
node ./dev/storage/recover.js -p POINT_ID
bun ./src/storage/recover.ts POINT_ID
```
you can check the `/recover` directory to see all available checkpoints and pick a point to load your data from, use the checkpoint directory name as the POINT_ID.
## Infrastructure
you can check the /recover directory to see all available checkpoints and pick a point to load your data from, use the checkpoint directory name as the POINT_ID.
### Communications
ddeep-core uses fastify to run a websocket server as it's a very efficient WebSocket framework that can handle tens of thousands of requests per second.
if you think that you can upgrade the communications structure, jump to [development](#development).
### CRDT
ddeep-core uses conflict resolution algorithm (HAM), now this is really fully implemented into ddeep-core from gun... so we recommend you check [this page](https://gun.eco/docs/Conflict-Resolution-with-Guns) for more info.
### Storage
ddeep-core uses radix to handle the persistent storage functionality, if `storage: true`.
### Policies
#### Check policies
There is notthing really fancy in check policies, It's just `true | false` callbacks.
#### AI-powered policies
Currently we are using the [SamLowe/roberta-base-go_emotions](https://huggingface.co/SamLowe/roberta-base-go_emotions) model through [HuggingFace inference](https://www.npmjs.com/package/@huggingface/inference).
We are working to upgrade this to a local running classification model running locally in the server itself for lower latency and more stability.
## Decentralized world
This project is part of a big movement to build a decentralized world where developers own their projects and users own their data, and **ddeep-core** is the core of this world.
This project is part of a big movement to build a decentralized world where developers own their projects and users own their data, and ddeep-core is the core of this world and part of the Ddeep Ecosystem.
Based on some simple benchmarks, ddeep-core can perform ~200K ops/sec on a low-end device of 2GB-4GB of ram, and we are always working to get better performance and would be happy to hear your experience with it on [Matrix](https://matrix.to/#/@multineon:gitter.im).
## Development
### `dev` directory
all the code lives in the `/dev` directory, and you can run `npm run build` to build your code to `/dist/build.js`, we use esbuild as it's the fastest tool we've ever used to build nodeJS code.
### License
If you want to develop this project, distribute it or help us improve it, you're welcome to do that, just check the [license](https://github.com/kais-radwan/ddeep-core/blob/main/LICENSE) and you're good to go.
If you want to develop this project, distribute it or help us improve it, you're welcome to do that, just check the license and you're good to go.
### NOTICE

@@ -439,33 +303,18 @@

## Thanks
We want to give our thanks to all the wonderful people helping us to decentralize the world, and also to:
- [Mark Nadal](https://github.com/amark) for building the best decentralized graph engine ever.
- [esbuild](https://esbuild.github.io/) for building the fastest bundler in the world.
- [fastify](https://fastify.dev/) for building a great fast web framework for nodeJS.
- [bytenode](https://github.com/bytenode/bytenode) for building a great bytecode compiler for NodeJS.
## The idea of ddeep-core
ddeep-core is a complete back-end NodeJS environment to run decentralized real-time databases, peers, and relays.
Build a complete back-end environment to run decentralized real-time databases, peers, relays, and more...
ddeep-core gives you the full control to configure it, scale it, change it, or do whatever you want... it's yours.
### Ddeep ecosystem
Ddeep core is part of ddeep ecosystem, a decentralized open-source ecosystem of tools for developers to build stable decentralized projects.
### Gun
ddeep-core works fine with Gun as a peer, and soon we will release the complete ddeep ecosystem so you get a great API to use with ddeep-core.
ddeep-core works fine with [Gun](https://gun.eco) as a peer, and soon we will release the complete ddeep ecosystem so you get a great API to use with ddeep-core.
the idea of this project was inspired by [Gun](https://gun.eco/), so we took the idea to the next level, the goal is to give developers a secure & stable way to build decentralized projects so we built `ddeep-core` using Bun and Typescript, added policies, upgraded the connections functionality, added more storage configurations and recovery checkpoints, and much more...
the idea of this project was inspired by [Gun](https://gun.eco), so we took the idea to the next level, the goal is to give developers a secure & stable way to build decentralized projects so we added [policies](#policies), [extensions](#extensions), upgraded the connections protocols, added more storage configurations and automations for restore checkpoints, and much more...
## Contact me
## Contact us
If you need any help, have any ideas, or want to code something together, you can always send me a message on [Matrix](https://matrix.to/#/@multineon:gitter.im).
If you need any help, have any ideas, or want to code something together, you can always send us a message on [Matrix](https://matrix.to/#/@multineon:gitter.im).
> I'm a little busy lately, I will always respone to any questions and messages, but the question is when :)
Built with ❤️ by Kais Radwan.

34

tsconfig.json
{
"compilerOptions": {
"target": "ES5",
"module": "CommonJS",
"strict": true,
"esModuleInterop": true,
"forceConsistentCasingInFileNames": true,
"sourceMap": false,
"moduleResolution": "Node",
"outDir": "dist"
}
}
"compilerOptions": {
"lib": ["ESNext"],
"module": "esnext",
"target": "esnext",
"moduleResolution": "bundler",
"moduleDetection": "force",
"allowImportingTsExtensions": true,
"noEmit": true,
"composite": true,
"strict": true,
"downlevelIteration": true,
"skipLibCheck": true,
"jsx": "react-jsx",
"allowSyntheticDefaultImports": true,
"forceConsistentCasingInFileNames": true,
"allowJs": true,
"types": [
"bun-types" // add Bun global
]
}
}
ddeep.config.js
dev/dup.js
dev/get.ts
dev/ham.js
dev/peers/emitter.js
dev/peers/listen.js
dev/policies/classes_model.ts
dev/policies/policies_builder.ts
dev/policies/policy_builder.ts
dev/policies/processor.ts
dev/policies/scanner.ts
dev/policies/scanner2.ts
dev/policies/smart_checker.ts
dev/put.ts
dev/serve.js
dev/storage/checkpoint.ts
dev/storage/get_from_graph.js
dev/storage/radisk.js
dev/storage/radix.js
dev/storage/radmigtmp.js
dev/storage/recover.js
dev/storage/store.js
dev/storage/yson.js
dist/build.js
dist/build.jsc
extensions.config.js
lib/commands/processor.js
lib/entry/ascii.txt
lib/ext/built-in/check_with_function.js
lib/ext/built-in/check.js
lib/ext/built-in/index.js
lib/ext/built-in/smart_checker.js
lib/ext/require.ts
lib/init/init.js
licenses.md
policies.config.js
Dockerfile

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc