josepot

// Request sequence pattern

// One of the reasons why I love Redux-Saga is because it allows me
// to handle all the common requests in a consistent manner,
// which reduces the amount of boilerplate and helps me keep things
// DRYer. I usually use a variation of the following utility Saga
// whenever I have to make a normal/promise request:

import {
  call,

josepot

// I usually use the request-sequence pattern
// (https://gist.github.com/josepot/cf63578fa81c7dba89ba156e71274537)
// And since 99% of the times that a saga errors it's because something
// went wrong with a request. That's not the only case when a saga can crash.
// The problem is that if there is an unhandled exception is a saga, that
// exception gets propagated all the way up to the rootSaga and the root
// saga will cancell all watchers... Which can be pretty annoying.
// This is one way to avoid such thing from happening:

// This is just a silly example on how to deal with a general exception.

josepot

const {map, pipe} = require('ramda');                                    
                                                                         
const operations = {                                                     
  NOT: a => ~a,                                                          
  COPY: a => a,                                                          
  AND: (a, b) => a & b,                                                  
  OR: (a, b) => a | b,                                                   
  LSHIFT: (a, b) => a << b,                                              
  RSHIFT: (a, b) => a >> b,                                              
};                                                                       

josepot

'use strict';

module.exports = {
  root: true,

  env: {
    browser: false,
    commonjs: false,
    es6: true,
    node: true,

josepot

Extrinsics

The last few weeks I've been prototyping an alternative to polkadot-js/api. My goal is to create a more modular, user-friendly, strongly-typed and light-weight version of polkadot-js/api.

I'm still not sure whether I will be able to accomplish those goals. However, I certanly hope that I will be able to share the knowledge and ideas that I gather during this attempt. That's why I'm creating this gist.

I'm not a technical writer, and I don't have a lot of time to spend on writing this. So, this is meant to be a "brain dump". although, hopefully someone who is good at writting documentation can use this for improving the substrate docs site.

josepot

import { fromHex, utf16StrToUtf8Bytes } from "@unstoppablejs/utils";            
import { jsonEncrypt } from "@polkadot/util-crypto";                            
import { createPair, Keyring } from "@polkadot/keyring";                        
                                                                                
const keyToBytes = (input: string | Uint8Array): Uint8Array =>                  
  typeof input === "string" ? fromHex(input) : input;                           
                                                                                
export function createBackUpFileContent(                                        
  addresses: Array<{                                                            
    name: string;                                                               

josepot

import { getSyncProvider } from "@polkadot-api/json-rpc-provider-proxy";
import { PathLike } from "fs";
import { readFile } from "fs/promises";

interface QueueNode<T> {
  value: T
  next?: QueueNode<T>
}

class Queue<T> {

josepot

{
  "lookup": [
    {
      "id": 0,
      "path": ["sp_core", "crypto", "AccountId32"],
      "params": [],
      "def": {
        "tag": "composite",
        "value": [
          {