@kynesyslabs/demosdk 1.0.21 → 1.0.23

package/src/types/web2/index.ts

@@ -1,76 +0,0 @@
-import forge from "node-forge"
-
-// NOTE
-// In case of POST requests, the data is the only parameter thus 'name' is ignored
-// In case of GET requests, we can have multiple parameters, thus 'name' is used to identify them
-export interface IParam {
-    name: string // Ignored in POST requests
-    value: any
-}
-
-// INFO Properties of a typical request as the client would send it
-// NOTE This should be the thing we receive from the handler as a request
-// NOTE Basically is the comlink message
-export interface IWeb2Payload {
-    type: "web2Request"
-    message: IWeb2Request
-    sender: any
-    receiver: any
-    timestamp: any
-    data: any
-    extra: any
-}
-
-// INFO A web2 result interface
-export interface IWeb2Result {
-    status: number
-    statusText: string
-    data: any
-}
-
-// INFO A complete web2 request
-export interface IWeb2Request {
-    raw: IRawWeb2Request
-    result: any
-    attestations: {}
-    hash: string
-    signature?: forge.pki.ed25519.BinaryBuffer
-}
-
-export enum EnumWeb2Methods {
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    DELETE = "DELETE",
-    PATCH = "PATCH"
-}
-
-// INFO A request without any attestations or identity data
-export interface IRawWeb2Request {
-    action: string
-    parameters: IParam[]
-    requestedParameters: [] | null
-    method: EnumWeb2Methods,
-    url: string
-    headers: any
-    minAttestations: number
-    // Handling the various stages of an IWeb2Request
-    stage: {
-        // The one that will handle the response too
-        origin: {
-            identity: forge.pki.ed25519.BinaryBuffer
-            connection_url: string
-        }
-        // Starting from 0, each attestation it is increased
-        hop_number: number
-    }
-}
-
-// ANCHOR Useful interfaces
-export interface IWeb2Attestation {
-    hash: string
-    timestamp: number
-    identity: forge.pki.PublicKey
-    signature: forge.pki.ed25519.BinaryBuffer
-    valid: boolean
-}

package/src/types/xm/index.ts

@@ -1,21 +0,0 @@
-
-export interface ITask {
-    type: string
-    params: any // TODO Define a decent type for this and use it everywhere
-    // TODO AND NOTE
-    // Here the client should send
-    // the signed transactions that it requires
-    signedPayloads: any[]
-}
-export interface IOperation {
-    chain: string
-    subchain: string
-    is_evm: boolean
-    rpc: string
-    task: ITask
-}
-
-export interface XMScript {
-    operations: { [key: string]: IOperation },
-    operations_order: string[]
-}

package/src/utils/dataManipulation.ts

@@ -1,37 +0,0 @@
-export async function ObjectToHex(obj: any): Promise<string> {
-  return Buffer.from(JSON.stringify(obj)).toString('hex')
-}
-
-export async function HexToObject(hex: string): Promise<any> {
-  return JSON.parse(Buffer.from(hex, 'hex').toString('utf8'))
-}
-
-/* REVIEW Could we possibly ditch the below functions? */
-
-// INFO forgeBuffer comes in as the raw result of forge methods
-export function ForgeToHex(forgeBuffer: any) {
-    console.log("[forge to string encoded]")
-    //console.log(forgeBuffer)
-    let rebuffer = Buffer.from(forgeBuffer)
-    forgeBuffer = rebuffer.toString("hex")
-    console.log("DECODED INTO:")
-    console.log("0x" + forgeBuffer)
-    return "0x" + forgeBuffer
-}
-
-// INFO finalArray must come out as an acceptable input for forge methods
-// NOTE The above and the below must be revertible with each other
-export function HexToForge(forgeString: string) {
-    forgeString = forgeString.slice(2)
-    let finalArray = new Uint8Array(64)
-    console.log("[string to forge encoded]")
-    //console.log(forgeString)
-    for (let i = 0; i < forgeString.length; i += 2) {
-        const hexValue = forgeString.substr(i, 2)
-        const decimalValue = parseInt(hexValue, 16)
-        finalArray[i / 2] = decimalValue
-    }
-    console.log("ENCODED INTO:")
-    //console.log(finalArray)
-    return finalArray
-}

package/src/utils/index.ts

@@ -1 +0,0 @@
-export * as dataManipulation from './dataManipulation'

package/src/websdk/DemosTransactions.ts

@@ -1,74 +0,0 @@
-import forge from 'node-forge'
-
-import { demos } from './demos'
-import { sha256 } from './utils/sha256'
-import * as skeletons from './utils/skeletons'
-import { DemosWebAuth } from './DemosWebAuth'
-
-import type { ValidityData, Transaction } from '@/types'
-
-export const DemosTransactions = {
-  // REVIEW All this part
-  // NOTE A courtesy to get a skeleton of transactions
-  empty: function () {
-    return skeletons.transaction
-  },
-  // NOTE Building a transaction without signing or hashing it
-  prepare: async function (data: any) {
-    // sourcery skip: inline-immediately-returned-variable
-    const thisTx = skeletons.transaction
-    // if (!data.timestamp) data.timestamp = Date.now()
-    // Assigning the transaction data to our object
-    // thisTx.content = data
-    return thisTx
-  },
-  // NOTE Signing a transaction after hashing it
-  sign: async function (raw_tx: Transaction, private_key: Uint8Array | null = null): Promise<Transaction> {
-    // If necessary, the private key is loaded from the state
-    if (!private_key) {
-      const id = DemosWebAuth.getInstance().keypair
-      private_key = id!.privateKey as Uint8Array
-      console.log('Private key loaded from state')
-    } else {
-      console.log('Private key provided')
-    }
-    console.log(private_key)
-    // Setting the public key
-    raw_tx.content.from = DemosWebAuth.getInstance().keypair!.publicKey as Uint8Array
-    // Hashing the content of the transaction
-    raw_tx.hash = await sha256(JSON.stringify(raw_tx.content))
-    // Signing the hash of the content
-    let signatureData = forge.pki.ed25519.sign({
-      message: raw_tx.hash,
-      encoding: 'utf8',
-      privateKey: private_key
-    }) // REVIEW if it is working right
-    raw_tx.signature = {
-      type: 'ed25519',
-      data: signatureData
-    }
-    // TODO Remove debug: error checking
-    let verified = forge.pki.ed25519.verify({
-      message: raw_tx.hash,
-      encoding: 'utf8',
-      signature: signatureData,
-      publicKey: DemosWebAuth.getInstance().keypair!.publicKey as Uint8Array
-    })
-    console.log('Signature verified: ' + verified)
-
-    return raw_tx // Hashed and signed
-  },
-  // NOTE Sending a transaction after signing it
-  confirm: async function (signedPayload: Transaction) {
-    let response = await demos.confirm(signedPayload);
-    response = JSON.parse(response);
-    return response;
-  },
-  broadcast: async function (validityData: ValidityData) {
-    // ValidityData does not need to be signed as it already contains a signature (in the Transaction object)
-    // and is sent as a ComLink (thus authenticated and signed by the sender)
-    let response = await demos.broadcast(validityData);
-    response = JSON.parse(response);
-    return response;
-  },
-}

package/src/websdk/DemosWebAuth.ts

@@ -1,186 +0,0 @@
-/* eslint-disable no-unused-vars */
-// @ts-ignore
-import forge from 'node-forge';
-import { required } from './utils/required';
-import * as forge_converter from './utils/forge_converter';
-import { RSA } from './rsa';
-import { IKeyPair, IStringifiedKeyPair } from './types/KeyPair';
-
-// TODO Could this be an universal "Sign in with DEMOS" ? Maybe
-
-// INFO Enabling DEMOS wallet connections in the browser exposing a singleton
-// NOTE All the methods below return an array of [boolean, string | any] where any can be the result of the method
-export class DemosWebAuth {
-	static _instance = <DemosWebAuth | null>null;
-	loggedIn = false;
-	keypair = <IKeyPair | null>null;
-	stringified_keypair = <IStringifiedKeyPair | null>null;
-
-	constructor() {
-		this.loggedIn = false;
-		this.keypair = null;
-		this.stringified_keypair = null;
-	}
-
-	/**
-	 * Description placeholder
-	 * @date 14/9/2023 - 13:52:34
-	 *
-	 * @static
-	 * @returns {DemosWebAuth}
-	 */
-	static getInstance() {
-		if (!this._instance) {
-			this._instance = new DemosWebAuth();
-		}
-		return this._instance;
-	}
-
-	async create(seed = "") {
-		if (!seed) {
-			seed = forge.random.getBytesSync(32);
-		}
-		console.log('[CREATE WALLET] Creating wallet...');
-		console.log('[CREATE WALLET] Seed: ' + seed);
-		let result = [true, {}];
-		try {
-			this.keypair = {
-				privateKey: null,
-				publicKey: null
-			};
-			this.keypair = forge.pki.ed25519.generateKeyPair({ seed });
-			console.log(this.keypair);
-			this.loggedIn = true;
-			console.log('[CREATE WALLET] Keypair created!');
-			// Stringify the keypair
-			console.log('[CREATE WALLET] Stringifying keypair...');
-			this.stringified_keypair = {
-				privateKey: forge_converter.forgeToString(this.keypair.privateKey),
-				publicKey: forge_converter.forgeToString(this.keypair.publicKey)
-			};
-			result = [true, this.stringified_keypair];
-			console.log(this.stringified_keypair);
-		} catch (e) {
-			// @ts-expect-error
-			result = [false, '[CREATE WALLET ERROR] ' + e.message];
-		}
-		return result;
-	}
-
-	// NOTE We just have to accept valid private keys and derive the public key from them
-	async login(privKey: boolean | Uint8Array) {
-		if (typeof privKey === 'string') {
-			console.log('[LOGIN] Converting private key from string...');
-			privKey = forge_converter.stringToForge(privKey);
-			if (!privKey) {
-				return [false, 'Cannot convert private key from that string!'];
-			}
-			console.log(privKey);
-			console.log('[LOGIN] Private key converted!');
-		}
-		console.log('[LOGIN WALLET] Logging in...');
-		if (!required(privKey, false)) {
-			return [false, 'You need to provide a private key!'];
-		}
-		// Serializing the private key as a string
-
-		// console.log("[LOGIN WALLET] Serializing private key...")
-		// this.keypair.privateKey = forge_converter.stringToForge(this.stringified_keypair.privateKey)
-		// console.log(this.keypair.privateKey)
-
-		this.keypair = {
-			privateKey: privKey as Uint8Array,
-			publicKey: null
-		};
-
-		// Logging in avoiding crashes on wrong private keys
-		try {
-			console.log('[LOGIN WALLET] Deriving public key from private key...');
-			this.keypair.publicKey = forge.pki.ed25519.publicKeyFromPrivateKey({ privateKey: privKey as Uint8Array });
-			this.stringified_keypair = {
-				privateKey: forge_converter.forgeToString(this.keypair.privateKey),
-				publicKey: forge_converter.forgeToString(this.keypair.publicKey)
-			};
-			this.loggedIn = true;
-
-			return [true, 'Successfully logged in!'];
-		} catch (e) {
-			console.log(e);
-			return [false, '[LOGIN ERROR] Cannot derive publicKey!'];
-		}
-	}
-
-	/**
-	 * @description Disconnects a wallet from the Demos chain
-	 * @returns {Promise<[boolean, string]>}
-	 **/
-	async logout() {
-		if (!required(this.keypair, false)) {
-			return [true, 'You are already logged out!'];
-		}
-		this.loggedIn = false;
-		this.keypair = null;
-		this.stringified_keypair = null;
-		return [true, 'Successfully logged out!'];
-	}
-
-	async sign(message: any) {
-		if (!required(this.keypair || this.stringified_keypair, false)) {
-			return [false, 'You need to login first!'];
-		}
-		// If needed, we derive the keys from the strings
-		if (!this.keypair) {
-			console.log('[SIGN WALLET] Deriving buffer keys from strings...');
-			this.keypair = {
-				privateKey: forge_converter.stringToForge(this.stringified_keypair?.privateKey),
-				publicKey: forge_converter.stringToForge(this.stringified_keypair?.publicKey)
-			};
-		}
-		let result = [true, {}];
-		try {
-			const sign_result = forge.pki.ed25519.sign({
-				message: message,
-				privateKey: this.keypair!.privateKey as Uint8Array
-			});
-
-			result = [true, sign_result];
-		} catch (e: any) {
-			result = [false, '[SIGN ERROR] ' + e.message];
-		}
-		return result; // Is already a [boolean, string]
-	}
-
-	async verify(message: any, s_signature: any, s_publicKey: any) {
-		let result = [true, ''];
-		// Deriving the buffers from the strings
-		const publicKey = forge_converter.stringToForge(s_publicKey);
-		const signature = forge_converter.stringToForge(s_signature);
-
-		if (!signature){
-			return [false, 'Invalid signature'];
-		}
-
-		if (!publicKey){
-			return [false, 'Invalid public key'];
-		}
-
-		try {
-			const verify_result = forge.pki.ed25519.verify({
-				message: message,
-				signature: signature,
-				publicKey: publicKey
-			});
-
-			result = [true, verify_result];
-		} catch (e: any) {
-			result = [false, '[VERIFY ERROR] ' + e.message];
-		}
-		return result; // Is already a [boolean, string]
-	}
-
-	rsa() {
-		return RSA.getInstance();
-	}
-}
-
-// export default DemosWebAuth;

package/src/websdk/Web2Transactions.ts

@@ -1,41 +0,0 @@
-// INFO This module exposes methods to quickly send Web2 requests to the network
-
-import * as skeletons from './utils/skeletons'
-// import demos from '../demos'
-import { DemosTransactions } from './DemosTransactions';
-import type { IWeb2Request, Transaction } from '@/types';
-
-// INFO Web2 Endpoints
-export async function prepareWeb2Payload (
-  action = 'GET',
-  url = 'https://icanhazip.com',
-  parameters = [],
-  requestedParameters = null,
-  headers = null,
-  minAttestations = 2
-): Promise<Transaction> {
-  // Generating an empty one and filling it
-  const web2_payload:IWeb2Request = skeletons.web2_request
-  web2_payload.raw.action = action
-  web2_payload.raw.url = url
-  web2_payload.raw.parameters = parameters
-  web2_payload.raw.headers = headers
-  web2_payload.raw.minAttestations = minAttestations
-  // Ensuring content is a known property
-  web2_payload.attestations = new Map()
-  web2_payload.hash = ''
-  web2_payload.signature = ''
-  web2_payload.result = ''
-
-  console.log('[Web2Transactions] Payload:')
-  console.log(web2_payload)
-  // REVIEW Finish upgrading to the new transaction system
-  // Creating a web2 payload
-  let web2_tx: Transaction = DemosTransactions.empty()
-  web2_tx.content.type = "web2Request"
-  web2_tx.content.data = ["web2Request", web2_payload]
-  // Signing the transaction
-  web2_tx = await DemosTransactions.sign(web2_tx)
-  // Returning the transaction
-  return web2_tx
-}

package/src/websdk/XMTransactions.ts

@@ -1,140 +0,0 @@
-// INFO Use the src/features/multichain/chainscript/chainscript.chs for the specs
-// NOTE This module is meant to be used with the demos websdk
-
-import type { Transaction, XMScript } from "@/types";
-import { DemosTransactions } from "./DemosTransactions";
-
-// INFO Using the methods below to create, manage and send chainscript-like scripts
-const XMTransactions = {
-  schemas: {
-    base_operation: {
-      chain: '',
-      subchain: '',
-      is_evm: false,
-      rpc: '',
-      conditional: false,
-      task: {
-        type: '',
-        params: {},
-        signedPayloads: <any[]>[]
-      }
-    },
-    condition_operation: {
-      operator: '',
-      statement: '',
-      callback: '',
-      alternative: ''
-    }
-  },
-
-  data: {
-    // NOTE This is a list of all operations that have been loaded in the current session
-    loaded_operations: <{[key: string]: any}>{},
-    operations_index: <(string|number)[]>[]
-  },
-
-  task: {},
-
-  operation: {
-    // ANCHOR Setters
-
-    // NOTE Creating and adding a new operation to the current session list
-    // megabudino was here: I added the conditional parameter; changed operation.task = task to not overwrite
-    create: function (name: string | number, chain: string, subchain: string, is_evm: boolean, rpc: string, task: { type: string; params: {}; signedPayloads: any[] }, conditional = false) {
-      // TODO Bugfix: implement a name
-      const operation = { ...XMTransactions.schemas.base_operation }
-      operation.chain = chain
-      operation.subchain = subchain
-      operation.is_evm = is_evm
-      operation.rpc = rpc
-      operation.conditional = conditional
-      operation.task = task
-      XMTransactions.data.loaded_operations[name] = operation
-      XMTransactions.data.operations_index.push(name)
-      return operation
-    },
-
-    // megabudino was here: this is the function that creates the condition operation
-    create_condition: function (name: string | number, operator: string, statement: string, callback: string, alternative: string) {
-      const condition = { ...XMTransactions.schemas.condition_operation }
-      condition.operator = operator
-      condition.statement = statement
-      condition.callback = callback
-      condition.alternative = alternative
-      XMTransactions.data.loaded_operations[name] = condition
-      XMTransactions.data.operations_index.push(name)
-      return condition
-    },
-
-    // megabudino was here: this is the function to push signed payloads to the task
-    push_signed_payload: function (name: string | number, signed_payload: any) {
-      XMTransactions.data.loaded_operations[name].task.signedPayloads.push(signed_payload)
-    },
-
-    // NOTE Deleting an operation from the current session list
-    delete: function (name: string | number) {
-      delete XMTransactions.data.loaded_operations[name]
-      const index = XMTransactions.data.operations_index.indexOf(name)
-      XMTransactions.data.operations_index.splice(index, 1)
-    },
-
-    clear: function () {
-      XMTransactions.data.loaded_operations = {}
-      XMTransactions.data.operations_index = []
-    },
-
-    // NOTE Changing operation order for an operation from the current session list
-    reorder: function (name: any, index: number) {
-      // FIXME Security: check boundaries to avoid circling
-      const operation_current = XMTransactions.data.operations_index.indexOf(name)
-      // Deleting and...
-      XMTransactions.data.operations_index.splice(operation_current, 1)
-      // ...inserting it at the new index
-      XMTransactions.data.operations_index.splice(index, 0, name)
-    },
-
-    // NOTE Updating an operation from the current session list
-    // megabudino was here: I added the conditional parameter; changed operation.task = task to not overwrite
-    update: function (name: string | number, chain: string, subchain: string, is_evm: boolean, rpc: string, task: { type: string; params: {} }, conditional: boolean) {
-      const operation = { ...XMTransactions.schemas.base_operation }
-      operation.chain = chain
-      operation.subchain = subchain
-      operation.is_evm = is_evm
-      operation.rpc = rpc
-      operation.task.type = task.type
-      operation.task.params = task.params
-      operation.conditional = conditional
-      XMTransactions.data.loaded_operations[name] = operation
-    },
-
-    // ANCHOR Getters
-
-    // NOTE Getting all the operations from the current session list
-    get: function () {
-      return XMTransactions.data.loaded_operations
-    },
-
-    // NOTE Getting an operation from the current session list by name
-    get_by_name: function (name: string | number) {
-      return XMTransactions.data.loaded_operations[name]
-    },
-
-    get_ordered_index: function () {
-      return XMTransactions.data.operations_index
-    }
-
-  }
-
-}
-
-async function prepareXMPayload(xm_payload: XMScript): Promise<Transaction> {
-  var xm_transaction: Transaction = DemosTransactions.empty()
-  xm_transaction.content.type = "crosschainOperation"
-  xm_transaction.content.data = ["crosschainOperation", xm_payload]
-  // Signing the transaction
-  xm_transaction = await DemosTransactions.sign(xm_transaction)
-  // Returning the transaction
-  return xm_transaction
-}
-
-export { XMTransactions, prepareXMPayload }