Algorand's response to ERC 1400

Hi everybody,

It’s time to create an Algorand equivalent of ERC 1400!

I have a stealth institutional digital assets platform venture that recently graduated from a leading fintech acclerator. I want to build it on Algorand. However, when we speak to potential institutional users and/or investors, they all say that would require ERC 1400 or an equivalent solution.

To help with institutional adoption of Algorand, we do need a robust response to ERC 1400.

Looking forward to your support in this regard.

Thanks.

1 Like

Hi, what are you missing from ERC 1400 on algorand?

For the record this is the standard that you reference here: https://github.com/ethereum/eips/issues/1411

I believe this standard can be achievable by multisig, rekey, clawback and freeze algorand layer 1 native features.

interface IERC1400 is IERC20 {

  // Document Management
  //A: this is part which is the most difficult, there would need to be smart contract, non blockchain app, or note field reference  of creator
  function getDocument(bytes32 _name) external view returns (string, bytes32);
  function setDocument(bytes32 _name, string _uri, bytes32 _documentHash) external;

  // Token Information
  //A: this is obtainable from the algorand
  function balanceOfByPartition(bytes32 _partition, address _tokenHolder) external view returns (uint256);
  function partitionsOf(address _tokenHolder) external view returns (bytes32[]);

  // Transfers
  //A: algorand supports note field, token owner or clawbacker can transfer tokens
  function transferWithData(address _to, uint256 _value, bytes _data) external;
  function transferFromWithData(address _from, address _to, uint256 _value, bytes _data) external;

  // Partition Token Transfers
  //A: token owner or clawbacker can transfer tokens
  function transferByPartition(bytes32 _partition, address _to, uint256 _value, bytes _data) external returns (bytes32);
  function operatorTransferByPartition(bytes32 _partition, address _from, address _to, uint256 _value, bytes _data, bytes _operatorData) external returns (bytes32);

  // Controller Operation
  //A: asa defined clawback account != null, i recommend the asa to be issued and managed by multisig, but the clawback can be also smart sig
  function isControllable() external view returns (bool);
  function controllerTransfer(address _from, address _to, uint256 _value, bytes _data, bytes _operatorData) external;
  function controllerRedeem(address _tokenHolder, uint256 _value, bytes _data, bytes _operatorData) external;

  // Operator Management
  //A: rekey multisig to another multisig
  function authorizeOperator(address _operator) external;
  function revokeOperator(address _operator) external;
  function authorizeOperatorByPartition(bytes32 _partition, address _operator) external;
  function revokeOperatorByPartition(bytes32 _partition, address _operator) external;

  // Operator Information
  //A: hash of multisig meta is multisig address, it is easy to determine all operators (msig accounts)
  function isOperator(address _operator, address _tokenHolder) external view returns (bool);
  function isOperatorForPartition(bytes32 _partition, address _operator, address _tokenHolder) external view returns (bool);

  // Token Issuance
  //A: transfer from reserve to account
  function isIssuable() external view returns (bool);
  function issue(address _tokenHolder, uint256 _value, bytes _data) external;
  function issueByPartition(bytes32 _partition, address _tokenHolder, uint256 _value, bytes _data) external;

  // Token Redemption
  //A: transfer from account to reserve
  function redeem(uint256 _value, bytes _data) external;
  function redeemFrom(address _tokenHolder, uint256 _value, bytes _data) external;
  function redeemByPartition(bytes32 _partition, uint256 _value, bytes _data) external;
  function operatorRedeemByPartition(bytes32 _partition, address _tokenHolder, uint256 _value, bytes _operatorData) external;

  // Transfer Validity
  function canTransfer(address _to, uint256 _value, bytes _data) external view returns (byte, bytes32);
  function canTransferFrom(address _from, address _to, uint256 _value, bytes _data) external view returns (byte, bytes32);
  function canTransferByPartition(address _from, address _to, bytes32 _partition, uint256 _value, bytes _data) external view returns (byte, bytes32, bytes32);    

  // Controller Events
  event ControllerTransfer(
      address _controller,
      address indexed _from,
      address indexed _to,
      uint256 _value,
      bytes _data,
      bytes _operatorData
  );

  event ControllerRedemption(
      address _controller,
      address indexed _tokenHolder,
      uint256 _value,
      bytes _data,
      bytes _operatorData
  );

  // Document Events
  event Document(bytes32 indexed _name, string _uri, bytes32 _documentHash);

  // Transfer Events
  event TransferByPartition(
      bytes32 indexed _fromPartition,
      address _operator,
      address indexed _from,
      address indexed _to,
      uint256 _value,
      bytes _data,
      bytes _operatorData
  );

  event ChangedPartition(
      bytes32 indexed _fromPartition,
      bytes32 indexed _toPartition,
      uint256 _value
  );

  // Operator Events
  event AuthorizedOperator(address indexed _operator, address indexed _tokenHolder);
  event RevokedOperator(address indexed _operator, address indexed _tokenHolder);
  event AuthorizedOperatorByPartition(bytes32 indexed _partition, address indexed _operator, address indexed _tokenHolder);
  event RevokedOperatorByPartition(bytes32 indexed _partition, address indexed _operator, address indexed _tokenHolder);

  // Issuance / Redemption Events
  event Issued(address indexed _operator, address indexed _to, uint256 _value, bytes _data);
  event Redeemed(address indexed _operator, address indexed _from, uint256 _value, bytes _data);
  event IssuedByPartition(bytes32 indexed _partition, address indexed _operator, address indexed _to, uint256 _value, bytes _data, bytes _operatorData);
  event RedeemedByPartition(bytes32 indexed _partition, address indexed _operator, address indexed _from, uint256 _value, bytes _operatorData);


}

Or did i not understand something on how ERC1400 should work?

I believe that the institutions can do it even much more secure on algorand. Mainly because of the freeze account definition and the native support of multisig and rekeying native support.

2 Likes

Thanks Ludo,

How about ERC 4337 - do you have or plan anything like that?:

https://www.linkedin.com/posts/ali-jamal-3019ab45_web3-etherum-erc4337-activity-7037636557855436800-tANd?utm_source=share&utm_medium=member_android

Johannes, please comment on ERC 1400.

Rgs. Sergo

1 Like

Is ERC 4337 just solution where someone else can pay fees for your txs? Or is it multisig feature with one required signature from someone else?

Ethereum has still long road to go to the state where algorand is, and if the fees will not get to the state where micropayments are possible, ethereum as a network will be less and less used :slight_smile: Benefits building on ethereum is big community and one code (solidity) can deploy to polygon or milkomeda, velas or others.

Btw, i am not from the algorand foundation nor the algorand inc. I am just developer building on algorand, and the fees on other chains, as well as layer 1 features on algorand just makes me to build here… On the other side the AF or lack of VCs is making me thinking go somewhere else…

1 Like

Thanks. Please share examples of your previous work. Have you done any development work for an online investment marketplace with tokenisation element?

Is your development experience only limited to Alogrand or have you done any work on Ethereum?

If yes, pls confirm the timeline and cost for developing a tokenisatoon engine based on ALGO and Eth.

Johannes, any comments/questions?

To complement @scholtz’s response, Algorand has essentially been supporting account abstraction almost from the beginning.
See Account Abstraction on Algorand - #2 by fabrice

Regarding ERC 1400, ARC-20: Smart ASA can be used as a base.

The thing on the mainnet I have is the Vote Coin project. It is open standard and open source implementation on onchain voting solution. Onchain community (for example DAO) can ask a question through the blockchain by writing specific json with their asa with self sign tx, any community members can cast a vote, there is also implemented encrypted voting so that the vote casts are not public until the dao publishes the encryption key, there is also voting delegation so that the onchain community members can delegate their voting power to other accounts so that the voting is in long term efficient.

I also have created AWallet, where i tried to make the official algorand wallet (now Pera wallet) to become open source (after one week on mainnet I suceceded :slight_smile: ). Interesting thing is that this wallet is still the only one which supports rekeying of multisig accounts, is using public set of nodes so that person can select one he trusts, or it is the only place where person can make his account to online state.

I am main coder / CTO of Aramid finance - EVM 2 AVM bridge. We have passed the audits, and launching mainnet soon. We have some delays because we need at least some VC funding so that we dont start with dry accounts. Daniel was at ETH Denver last week. Aramid decentralized permissionless Algorand Polygon Ethereum Aurora bridge - YouTube

I am main algorand coder for Diatomix. Impermanent loss solution. Basically you can profit from AMM moves and stick the investment to dollar value. Verum capital received VC funding and raising now for second round. The project is deployed to testnet for closed group.

I submitted to the GHH3 project stabilitas - National stablecoins minting by smart contract with oracle from ECB, but for some reason it did not make it to top 4 projects. Chat project is according to judges better. (Or my conspriracy theory algorand foundation did not want to do nowadays anything to do with stablecoins because of the Gary Gensler)

I was overall winner of swiss blockchain hackathon with project DREM - Decentralized real estate marketplace. I have not found any VCs yet to invest into real estates. But i am developing it slowly in my spare time. The vote coin or stabilitas are basically support projects with my long term vision.

I was in the past president of the exchange chamber at regulated commodity exchange (CEB), later I was profitable prop equity trader doing arbitrage and market making in one of the largest investment banks in eastern europe (Wood&Co), later i created data center for EP holding (EPC), later i have created covid testing app which has tested something like 1 mil people in EU.

I was winner at few hackathons… For example eID hack, EU vs Virus, HackujStat, Encode hack, SB Hack, El salvador bitcoin bankathon, DAO hack, Algo hackjam, Greenhouse hack, … With the vote coin I was in Encode accelerator.

What I am the mostly grateful to the AF is that I am one of the relay node runners, however I believe that the relays should be in open competition who provide better services, not selected in the competition by central authority.

1 Like

On algorand to issue token it is one api call… There are forms which allows you to do it.

On ethereum you have to wisely decide which smart contract you want to use. The worst thing is that metamask (or other eth wallets) does not have note field support (there is with extension for eth native token, but erc20 does not have it by protocol).

So the timeline to do it on algorand is like 5 mins by non coder. (Even with multisig support) On ethereum you have to have coder and safe way to deploy contract. For example there is missing the multisig support so you might want the wise coder…

So the main question is what do you want to do with your token… You should have some utilisation so that it is not just another scam token. And if you enable clawback and freeze features, you must have very good reason for it. (Eg. the security legislation compliance) If this is the case, the coding costs will be significantly lower than the lawyer costs.

1 Like