Why PoliPoli adopts NEM?

LCNEM (of which I am CEO) is going to provide LCNEM Wallet for cooperation and advices for using NEM technology.

PR times

PoliPoli is a startup company, which is trying to “make politics close to citizens” which is difficult with exinsting business model even though it is needed, by creating a token economy.

I asked why PoliPoli adopts NEM to Mr.Ito who is a CEO of PoliPoli. I introduce his opinion.

 

Kazuma Ito – The CEO of PoliPoli

Q.How do you use NEM?

 

 

 

 

PoliPoli create a token economy consists of citizens and politicians.

Political communities are tend to gather slanders, which lead to make speakers dispirited.  Furthermore, in Japan, mainly in rural areas, politicians have trouble in lacking of moneys, and the ways of gathering supporters are still  analogue and inefficient.

Making a business model which solve these problems with existing ways was difficult, but PoliPoli realize it by Evaluation Economy Model by using the token economy.

We issue this original token “Polin” with NEM mosaic function.

I see. Owing to Evaluation Economy Model, you can make incentives not to slander and incentives for politicians.

It seems to follow my advices on not leaving tokens no value.

 

Supplement

Consider \(n\) is a number of users, \(X\) is an index of a ranking of given Polin amount, \(Y\) is an index of a ranking of giving Polin amount for politicians, and\(Z\) is an index of a ranking of owing Polin amount, The trust score is calculated as below.

$$ TrustScore = 60\left(1-log_nX\right)+30\left(1-log_nY\right)+10\left(1-log_nZ\right) $$

To see more, I suggest you to see the website of PoliPoli.

 

Q.Why did you decide to adopt NEM?

 

 

 

 

Because it is easy to implement token functions to our service and to enhance securities. We use the multisig function to enhance a security of saving Polin.

Then, because of blocks of NEM blockchain having many rooms to contain transactions, the transaction fee cost of NEM is still low.

 

 

Certainly, the transaction fee of NEM is mostly equal to designated lowest criteria.

The transaction fee of NEM can be calculated as below.

$$ max \left( 0.05, XemFee( \frac{8999999999}{s} \times x) – 0.05 floor \left( 0.8 \times log \frac{9000000000 \times {10}^6}{s \times {10}^d} \right) \right)$$

$$ where XemFee\left(x\right) = min \left( 0.05 ceiling \left( \frac{x}{10000} \right) , 1.25 \right) $$

I think this will continue to be as it is for the moment.

To see more, see NEMモザイク送金手数料をOctaveで4次元グラフにしてみた if you can read Japanese.

Q.Ethereum was also one of choices, wasn’t it?

 

 

 

 

We considered to use ERC20 contract of Ethereum, but we decided to use NEM, because if there are some bugs in contracts, we can modify it easily, and the implementation of token functions to our service is easy.

I heard that the token economy project called Totellus also adopts NEM.

 

 

I see.

Technical supplements

Ethereum blockchain was not created for the purpose of only remittance. It is the blockchain to which deploy smartcontract programs and save the executed data of the programs.

There is no specialized function to issue tokens, but it can be done by deploying the program following to the interface called ERC20, which make the contract able to be as a token.

I show you the ERC20 interface.


contract ERC20 {
  function totalSupply() constant returns (uint totalSupply);
  function balanceOf(address _owner) constant returns (uint balance);
  function transfer(address _to, uint _value) returns (bool success);
  function transferFrom(address _from, address _to, uint _value) returns (bool success);
  function approve(address _spender, uint _value) returns (bool success);
  function allowance(address _owner, address _spender) constant returns (uint remaining);
  event Transfer(address indexed _from, address indexed _to, uint _value);
  event Approval(address indexed _owner, address indexed _spender, uint _value);
}

By deploying a program which extends this interface, we issue tokens. Then, we implement programs of making transactions of this contract.

On the other hand, NEM provides necessity minimum functions,  for example, making original tokens, in native. NEM doesn’t accept contract program deployments.

In NEM, you can make original tokens with Nano Wallet in GUI.

To transfer tokens, you will use REST API. There is a convenient wrapper library called nem2-sdk, so I think you will use it.

I’ll show you the flow of making NEM transaction, and the method in nem2-sdk which you will use.

1.Create an object of the transaction.


export class TransferTransaction extends Transaction {
    /**
     * Create a transfer transaction object
     * @param deadline - The deadline to include the transaction.
     * @param recipient - The recipient of the transaction.
     * @param mosaics - The array of mosaics.
     * @param message - The transaction message.
     * @param networkType - The network type.
     * @returns {TransferTransaction}
     */
    public static create(deadline: Deadline,
                         recipient: Address,
                         mosaics: Mosaic[],
                         message: Message,
                         networkType: NetworkType): TransferTransaction {
        return new TransferTransaction(networkType,
            3,
            deadline,
            new UInt64([0, 0]),
            recipient,
            mosaics,
            message);
    }
}

 

2.Make a digital signature


export class Account {
    /**
     * @internal
     * @param address
     * @param keyPair
     */
    private constructor(
                        /**
                         * The account address.
                         */
                        public readonly address: Address,
                        /**
                         * The account keyPair, public and private key.
                         */
                        private readonly keyPair: IKeyPair) {
    }

    /**
     * Sign a transaction
     * @param transaction - The transaction to be signed.
     * @return {SignedTransaction}
     */
    public sign(transaction: Transaction): SignedTransaction {
        return transaction.signWith(this);
    }
}

 

3.Announce the transaction and the digital signature


export class TransactionHttp extends Http implements TransactionRepository {
    /**
     * Constructor
     * @param url
     */
    constructor(private readonly url: string) {
        super(url);
        this.transactionRoutesApi = new TransactionRoutesApi(this.apiClient);
    }

    /**
     * Send a signed transaction
     * @param signedTransaction - Signed transaction
     * @returns Observable
     */
    public announce(signedTransaction: SignedTransaction): Observable {
        return Observable.fromPromise(this.transactionRoutesApi.announceTransaction(signedTransaction))
            .map((transactionAnnounceResponseDTO) => {
                return new TransactionAnnounceResponse(transactionAnnounceResponseDTO.message);
            });
    }
}

nem2-sdk seems to be going to support not only JavaScript/TypeScript, but also  Java/Kotlin, C#/.NET, PHP, Python, Go, and Ruby.

Ethereum’s feature that deploying contract program to the blockchain which we can’t tamper gives Ethereum strengths that Ethereum enables decentralized smart-contract.

However, if you deploy the program to the blockchain, it means you can’t change the program, so you will have difficulty (if you design the contract program well, it is not impossible but difficult) in modifying the program when some bugs are found.

PoliPoli considered the strength of Ethereum and the trade-off of modification possibility, and then decided to use NEM.

Q.What is your goal?

 

 

 

 

We want to make the service decentralized gradually, and eventually, we want to make it a decentralized autonomous service.

Ethereum is suited for making decentralized autonomous organizations, but we have no decision whether we use Ethereum or NEM for it. The way of using NEM exist certainly.

 

 

Indeed, making a decentralized autonomous organization with current NEM is difficult and Ethereum is suited for it. However, after NEM2 launch, if we can make use of IPFS  to decentralize contract program deployments with leaving the program modification possibility,  there are some possibilities to make decentralized autonomous service with NEM.

 

 

 

Dear Mr Ito, thank you for your answers!

PoliPoli consists of young people, and LCNEM also consists of young people. We will make a new movement with young power. We would appreciate your supports!