solution: subscribe, show and edit erc20 allowances

package.json

@@ -28,7 +28,7 @@
  "packages/*"
  ],
  "resolutions": {
- "@emeraldpay/api": "https://artifacts.emerald.cash/builds/emerald-api-js/2c423635/emeraldpay-api-v0.4.0-dev.tgz",
- "@emeraldpay/api-node": "https://artifacts.emerald.cash/builds/emerald-api-js/2c423635/emeraldpay-api-node-v0.4.0-dev.tgz"
+ "@emeraldpay/api": "https://artifacts.emerald.cash/builds/emerald-api-js/ebb1aeb6/emeraldpay-api-v0.4.0-dev.tgz",
+ "@emeraldpay/api-node": "https://artifacts.emerald.cash/builds/emerald-api-js/ebb1aeb6/emeraldpay-api-node-v0.4.0-dev.tgz"
  }
 }

packages/core/src/IpcCommands.ts

@@ -24,6 +24,10 @@ export enum IpcCommands {
  /** @deprecated */
  BROADCAST_TX = 'broadcast-tx',
 
+ // Allowance service
+ ALLOWANCE_SET_TOKENS = 'allowance-set-tokens',
+ ALLOWANCE_SUBSCRIBE_ADDRESS = 'allowance-subscribe-address',
+
  // Balance service
  BALANCE_SET_TOKENS = 'balance-set-tokens',
  BALANCE_SUBSCRIBE = 'balance-subscribe',

packages/core/src/blockchains/index.ts

@@ -1,5 +1,7 @@
 export { EthereumMessage, isStructuredMessage } from './ethereum';
 export {
+ INFINITE_ALLOWANCE,
+ MAX_DISPLAY_ALLOWANCE,
  InputDataDecoder,
  Token,
  TokenAmount,
@@ -8,6 +10,7 @@ export {
  TokenRegistry,
  decodeData,
  isToken,
+ isWrappedToken,
  tokenAbi,
  wrapTokenAbi,
 } from './tokens';

packages/core/src/blockchains/tokens/allowance.ts

@@ -0,0 +1,10 @@
+import BigNumber from 'bignumber.js';
+
+/**
+ * Highest possible value for allowance, calculated as 2^256-1
+ */
+export const INFINITE_ALLOWANCE = new BigNumber('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+/**
+ * Max display value before showing infinite symbol, calculated as 2^128
+ */
+export const MAX_DISPLAY_ALLOWANCE = new BigNumber('0x100000000000000000000000000000000');

packages/core/src/blockchains/tokens/index.ts

@@ -1,3 +1,4 @@
 export { tokenAbi, wrapTokenAbi } from './abi';
+export { INFINITE_ALLOWANCE, MAX_DISPLAY_ALLOWANCE } from './allowance';
 export { InputDataDecoder, decodeData } from './decoder';
-export { Token, TokenAmount, TokenData, TokenInstances, TokenRegistry, isToken } from './registry';
+export { Token, TokenAmount, TokenData, TokenInstances, TokenRegistry, isToken, isWrappedToken } from './registry';

packages/core/src/blockchains/tokens/registry.ts

@@ -4,6 +4,12 @@ import { BlockchainCode, blockchainIdToCode } from '../blockchains';
 
 const TOKEN_TYPES = ['ERC20', 'ERC721', 'ERC1155'] as const;
 
+const WRAPPED_TOKENS: Readonly<Partial<Record<BlockchainCode, string>>> = {
+ [BlockchainCode.ETH]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+ [BlockchainCode.ETC]: '0x1953cab0E5bFa6D4a9BaD6E05fD46C1CC6527a5a',
+ [BlockchainCode.Goerli]: '0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6',
+};
+
 export interface TokenData {
  address: string;
  blockchain: number;
@@ -14,7 +20,6 @@ export interface TokenData {
  stablecoin?: boolean;
  symbol: string;
  type: (typeof TOKEN_TYPES)[number];
- wrapped?: boolean;
 }
 
 export function isToken(value: unknown): value is TokenData {
@@ -26,6 +31,10 @@ export function isToken(value: unknown): value is TokenData {
  );
 }
 
+export function isWrappedToken(token: TokenData): boolean {
+ return token.address.toLowerCase() === WRAPPED_TOKENS[blockchainIdToCode(token.blockchain)]?.toLowerCase();
+}
+
 export class TokenAmount extends BigAmount {
  readonly token: TokenData;
 
@@ -39,15 +48,42 @@ export class TokenAmount extends BigAmount {
  return BigAmount.is(value) && 'token' in value && value.token != null && typeof value.token === 'object';
  }
 
+ protected convert(amount: this): this {
+ return new TokenAmount(amount, this.units, this.token) as this;
+ }
+
+ protected copyWith(value: BigNumber): this {
+ return this.convert(super.copyWith(value));
+ }
+
  plus(amount: this): this {
- return new TokenAmount(super.plus(amount), amount.units, this.token) as this;
+ return this.convert(super.plus(amount));
+ }
+
+ minus(amount: this): this {
+ return this.convert(super.minus(amount));
+ }
+
+ multiply(amount: number | BigNumber): this {
+ return this.convert(super.multiply(amount));
+ }
+
+ divide(amount: number | BigNumber): this {
+ return this.convert(super.divide(amount));
+ }
+
+ max(amount: this): this {
+ return this.convert(super.max(amount));
+ }
+
+ min(amount: this): this {
+ return this.convert(super.min(amount));
  }
 }
 
 export class Token implements TokenData {
  private readonly _pinned?: boolean;
  private readonly _stablecoin?: boolean;
- private readonly _wrapped?: boolean;
 
  readonly address: string;
  readonly blockchain: number;
@@ -60,7 +96,6 @@ export class Token implements TokenData {
  constructor(token: TokenData) {
  this._pinned = token.pinned;
  this._stablecoin = token.stablecoin;
- this._wrapped = token.wrapped;
 
  this.blockchain = token.blockchain;
  this.decimals = token.decimals;
@@ -81,7 +116,7 @@ export class Token implements TokenData {
  }
 
  get wrapped(): boolean {
- return this._wrapped ?? false;
+ return isWrappedToken(this);
  }
 
  getUnits(): Units {
@@ -169,6 +204,12 @@ export class TokenRegistry {
  return instances.has(address.toLowerCase());
  }
 
+ hasAnyToken(blockchain: BlockchainCode): boolean {
+ const instances = this.instances.get(blockchain);
+
+ return (instances?.size ?? 0) > 0;
+ }
+
  getStablecoins(blockchain: BlockchainCode): Token[] {
  const instances = this.instances.get(blockchain);
 

packages/core/src/index.ts

@@ -6,6 +6,8 @@ import * as workflow from './workflow';
 export { blockchains, config, workflow, utils };
 
 export {
+ INFINITE_ALLOWANCE,
+ MAX_DISPLAY_ALLOWANCE,
  Blockchains,
  BlockchainCode,
  Coin,

packages/core/src/workflow/create-tx/CreateErc20ApproveTx.spec.ts

@@ -0,0 +1,179 @@
+import { Wei } from '@emeraldpay/bigamount-crypto';
+import { BlockchainCode, INFINITE_ALLOWANCE, TokenData, TokenRegistry } from '../../blockchains';
+import { DEFAULT_GAS_LIMIT_ERC20, EthereumTransactionType } from '../../transaction/ethereum';
+import { ApproveTarget, CreateErc20ApproveTx } from './CreateErc20ApproveTx';
+import { ValidationResult } from './types';
+
+describe('CreateErc20ApproveTx', () => {
+ const wethTokenData: TokenData = {
+ name: 'Wrapped Ether',
+ blockchain: 10005,
+ address: '0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6',
+ symbol: 'WETG',
+ decimals: 18,
+ type: 'ERC20',
+ };
+ const weenusTokenData: TokenData = {
+ name: 'Weenus',
+ blockchain: 10005,
+ address: '0xaFF4481D10270F50f203E0763e2597776068CBc5',
+ symbol: 'WEENUS',
+ decimals: 18,
+ type: 'ERC20',
+ stablecoin: true,
+ };
+
+ const tokenRegistry = new TokenRegistry([wethTokenData, weenusTokenData]);
+
+ const wethToken = tokenRegistry.byAddress(BlockchainCode.Goerli, '0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6');
+ const weenusToken = tokenRegistry.byAddress(BlockchainCode.Goerli, '0xaFF4481D10270F50f203E0763e2597776068CBc5');
+
+ test('should create legacy approve tx', () => {
+ const tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: wethToken.getAmount(0),
+ type: EthereumTransactionType.LEGACY,
+ });
+
+ expect(tx.amount.number.toNumber()).toEqual(0);
+ expect(tx.gas).toBe(DEFAULT_GAS_LIMIT_ERC20);
+ expect(tx.gasPrice?.number.toNumber()).toEqual(0);
+ expect(tx.totalBalance.number.toNumber()).toEqual(0);
+ });
+
+ test('should create eip1559 approve tx', () => {
+ const tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: wethToken.getAmount(0),
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.amount.number.toNumber()).toEqual(0);
+ expect(tx.gas).toEqual(DEFAULT_GAS_LIMIT_ERC20);
+ expect(tx.maxGasPrice?.number.toNumber()).toEqual(0);
+ expect(tx.priorityGasPrice?.number.toNumber()).toEqual(0);
+ expect(tx.totalBalance.number.toNumber()).toEqual(0);
+ });
+
+ test('should set target', () => {
+ let tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ target: ApproveTarget.MANUAL,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: wethToken.getAmount(1),
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.amount.equals(wethToken.getAmount(0))).toBeTruthy();
+
+ const amount = wethToken.getAmount(3);
+
+ tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ target: ApproveTarget.MAX_AVAILABLE,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: amount,
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.amount.equals(amount)).toBeTruthy();
+
+ tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ target: ApproveTarget.INFINITE,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: wethToken.getAmount(0),
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.amount.number.eq(INFINITE_ALLOWANCE)).toBeTruthy();
+ });
+
+ test('should change amount and target', () => {
+ const amount = wethToken.getAmount(1);
+
+ const tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: amount,
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.target).toEqual(ApproveTarget.MANUAL);
+
+ tx.target = ApproveTarget.MAX_AVAILABLE;
+
+ expect(tx.amount.equals(amount)).toBeTruthy();
+
+ tx.target = ApproveTarget.INFINITE;
+
+ expect(tx.amount.number.eq(INFINITE_ALLOWANCE)).toBeTruthy();
+
+ tx.amount = amount;
+
+ expect(tx.target).toEqual(ApproveTarget.MANUAL);
+ });
+
+ test('should change token', () => {
+ const amount = wethToken.getAmount(1);
+
+ const tx = new CreateErc20ApproveTx({
+ amount,
+ blockchain: BlockchainCode.Goerli,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: amount,
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ const weenusAmount = weenusToken.getAmount(1);
+
+ tx.setToken(weenusToken, new Wei(0), weenusAmount, true);
+
+ expect(tx.token.symbol).toEqual(weenusToken.symbol);
+ expect(tx.amount.number.eq(weenusAmount.number)).toBeTruthy();
+ expect(tx.totalTokenBalance.equals(weenusAmount)).toBeTruthy();
+ });
+
+ test('should validate tx', () => {
+ const tx = new CreateErc20ApproveTx({
+ blockchain: BlockchainCode.Goerli,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: wethToken.getAmount(0),
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.validate()).toEqual(ValidationResult.NO_FROM);
+
+ tx.approveBy = '0xe62c6f33a58d7f49e6b782aab931450e53d01f12';
+
+ expect(tx.validate()).toEqual(ValidationResult.NO_TO);
+
+ tx.allowFor = '0x3f54eb67fea225d0a21263f1a7cb456e342cb1e8';
+
+ expect(tx.validate()).toEqual(ValidationResult.OK);
+ });
+
+ test('should build tx', () => {
+ const tx = new CreateErc20ApproveTx({
+ approveBy: '0xe62c6f33a58d7f49e6b782aab931450e53d01f12',
+ allowFor: '0x3f54eb67fea225d0a21263f1a7cb456e342cb1e8',
+ blockchain: BlockchainCode.Goerli,
+ token: wethTokenData,
+ totalBalance: new Wei(0),
+ totalTokenBalance: wethToken.getAmount(0),
+ type: EthereumTransactionType.EIP1559,
+ });
+
+ expect(tx.build().data.length).toBeGreaterThan(2);
+ });
+});