2591655167

Build Type

github

Committed by GitHub

Commit Message

Merge 45afc4f47 into 71eebf429

Pull Request Pull Request #123: Add support for Klaytn, SFI

Run Details

25 of 38 branches covered (65.79%)

Branch coverage included in aggregate %.

6 of 65 new or added lines in 7 files covered. (9.23%)

4952 existing lines in 20 files now uncovered.

1428 of 6458 relevant lines covered (22.11%)

0.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

35.04

/src/bridge/erc20.ts

import {Signer} from "@ethersproject/abstract-signer";
import type {TransactionResponse} from "@ethersproject/abstract-provider";
import {
    BigNumber,
    type BigNumberish,
} from "@ethersproject/bignumber";
import type {
    PopulatedTransaction,
    ContractTransaction,
} from "@ethersproject/contracts";

import {
    ERC20Factory,
    ERC20Contract,
} from "@contracts";

import {rpcProviderForChain} from "@internal/rpcproviders";

import {
    executePopulatedTransaction,
    rejectPromise
} from "@common/utils";

import type {SignerOrProvider} from "@common/types";

import {GasUtils} from "./gasutils";

export const MAX_APPROVAL_AMOUNT = BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");


export type ApproveArgs = {
    spender: string;
    amount?: BigNumberish;
}

export type TokenParams = {
    tokenAddress: string;
    chainId:      number;
}

class ERC20 {
    readonly address: string;
    readonly chainId: number;
    private readonly instance: ERC20Contract;

    constructor(args: TokenParams) {
        this.address = args.tokenAddress;
        this.chainId = args.chainId;

        this.instance = ERC20Factory.connect(this.address, null);
    }

    private connectContract(provider?: SignerOrProvider): ERC20Contract {
        provider = provider ? provider : rpcProviderForChain(this.chainId);

        return this.instance.connect(provider)
    }

    async approve(args: ApproveArgs, signer: Signer,
    ): Promise<ContractTransaction> {
        const
            contract   = this.connectContract(signer),
            approveTxn = this._buildApproveTransaction(args, contract);

        return executePopulatedTransaction(approveTxn, signer)
    }

    async buildApproveTransaction(
        args:      ApproveArgs,
        provider?: SignerOrProvider
    ): Promise<PopulatedTransaction> {
        const contract = this.connectContract(provider);
        return this._buildApproveTransaction(args, contract)
    }

    private async _buildApproveTransaction(
        args:     ApproveArgs,
        contract: ERC20Contract
    ): Promise<PopulatedTransaction> {
        const {spender, amount=MAX_APPROVAL_AMOUNT} = args;

        return contract
            .populateTransaction
            .approve(spender, amount)
            .then(txn => {
                return GasUtils.populateGasParams(
                    this.chainId,
                    txn,
                    "approve"
                )
            })
            .catch(rejectPromise)
    }

    async balanceOf(
        address: string
    ): Promise<BigNumber> {
        return this.connectContract().balanceOf(address)
    }

    async allowanceOf(
        owner: string,
        spender: string
    ): Promise<BigNumber> {
        return this.connectContract().allowance(owner, spender)
    }
}

export async function approve(
    approveArgs: ApproveArgs,
    tokenParams: TokenParams,
    signer:      Signer
): Promise<TransactionResponse> {
    return new ERC20(tokenParams).approve(approveArgs, signer)
}

export async function buildApproveTransaction(
    approveArgs: ApproveArgs,
    tokenParams: TokenParams
): Promise<PopulatedTransaction> {
    return new ERC20(tokenParams).buildApproveTransaction(approveArgs)
}

export async function balanceOf(
    address:     string,
    tokenParams: TokenParams
): Promise<BigNumber> {
    return new ERC20(tokenParams).balanceOf(address)
}

export async function allowanceOf(
    owner:       string,
    spender:     string,
    tokenParams: TokenParams
): Promise<BigNumber> {
    return new ERC20(tokenParams).allowanceOf(owner, spender)
}

1	import {Signer} from "@ethersproject/abstract-signer";	2✔
2	import type {TransactionResponse} from "@ethersproject/abstract-provider";	2✔
3	import {	2✔
4	BigNumber,	2✔
5	type BigNumberish,	2✔
6	} from "@ethersproject/bignumber";	2✔
7	import type {	2✔
8	PopulatedTransaction,	2✔
9	ContractTransaction,	2✔
10	} from "@ethersproject/contracts";	2✔
11		2✔
12	import {	2✔
13	ERC20Factory,	2✔
14	ERC20Contract,	2✔
15	} from "@contracts";	2✔
16		2✔
17	import {rpcProviderForChain} from "@internal/rpcproviders";	2✔
18		2✔
19	import {	2✔
20	executePopulatedTransaction,	2✔
21	rejectPromise	2✔
22	} from "@common/utils";	2✔
23		2✔
24	import type {SignerOrProvider} from "@common/types";	2✔
25		2✔
26	import {GasUtils} from "./gasutils";	2✔
27		2✔
28	export const MAX_APPROVAL_AMOUNT = BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");	2✔
29		2✔
30		2✔
31	export type ApproveArgs = {	2✔
32	spender: string;	2✔
33	amount?: BigNumberish;	2✔
34	}	2✔
35		2✔
36	export type TokenParams = {	2✔
37	tokenAddress: string;	2✔
38	chainId: number;	2✔
39	}	2✔
40		2✔
UNCOV 41	class ERC20 {	×
UNCOV 42	readonly address: string;	×
UNCOV 43	readonly chainId: number;	×
UNCOV 44	private readonly instance: ERC20Contract;	×
UNCOV 45		×
UNCOV 46	constructor(args: TokenParams) {	×
UNCOV 47	this.address = args.tokenAddress;	×
UNCOV 48	this.chainId = args.chainId;	×
UNCOV 49		×
UNCOV 50	this.instance = ERC20Factory.connect(this.address, null);	×
UNCOV 51	}	×
UNCOV 52		×
UNCOV 53	private connectContract(provider?: SignerOrProvider): ERC20Contract {	×
UNCOV 54	provider = provider ? provider : rpcProviderForChain(this.chainId);	×
UNCOV 55		×
UNCOV 56	return this.instance.connect(provider)	×
UNCOV 57	}	×
UNCOV 58		×
UNCOV 59	async approve(args: ApproveArgs, signer: Signer,	×
UNCOV 60	): Promise<ContractTransaction> {	×
UNCOV 61	const	×
UNCOV 62	contract = this.connectContract(signer),	×
UNCOV 63	approveTxn = this._buildApproveTransaction(args, contract);	×
UNCOV 64		×
UNCOV 65	return executePopulatedTransaction(approveTxn, signer)	×
UNCOV 66	}	×
UNCOV 67		×
UNCOV 68	async buildApproveTransaction(	×
UNCOV 69	args: ApproveArgs,	×
UNCOV 70	provider?: SignerOrProvider	×
UNCOV 71	): Promise<PopulatedTransaction> {	×
UNCOV 72	const contract = this.connectContract(provider);	×
UNCOV 73	return this._buildApproveTransaction(args, contract)	×
UNCOV 74	}	×
UNCOV 75		×
UNCOV 76	private async _buildApproveTransaction(	×
UNCOV 77	args: ApproveArgs,	×
UNCOV 78	contract: ERC20Contract	×
UNCOV 79	): Promise<PopulatedTransaction> {	×
UNCOV 80	const {spender, amount=MAX_APPROVAL_AMOUNT} = args;	×
UNCOV 81		×
UNCOV 82	return contract	×
UNCOV 83	.populateTransaction	×
UNCOV 84	.approve(spender, amount)	×
UNCOV 85	.then(txn => {	×
UNCOV 86	return GasUtils.populateGasParams(	×
UNCOV 87	this.chainId,	×
UNCOV 88	txn,	×
UNCOV 89	"approve"	×
UNCOV 90	)	×
UNCOV 91	})	×
UNCOV 92	.catch(rejectPromise)	×
UNCOV 93	}	×
UNCOV 94		×
UNCOV 95	async balanceOf(	×
UNCOV 96	address: string	×
UNCOV 97	): Promise<BigNumber> {	×
UNCOV 98	return this.connectContract().balanceOf(address)	×
UNCOV 99	}	×
UNCOV 100		×
UNCOV 101	async allowanceOf(	×
UNCOV 102	owner: string,	×
UNCOV 103	spender: string	×
UNCOV 104	): Promise<BigNumber> {	×
UNCOV 105	return this.connectContract().allowance(owner, spender)	×
UNCOV 106	}	×
UNCOV 107	}	×
108		2✔
109	export async function approve(	2✔
UNCOV 110	approveArgs: ApproveArgs,	×
UNCOV 111	tokenParams: TokenParams,	×
UNCOV 112	signer: Signer	×
UNCOV 113	): Promise<TransactionResponse> {	×
UNCOV 114	return new ERC20(tokenParams).approve(approveArgs, signer)	×
UNCOV 115	}	×
116		2✔
117	export async function buildApproveTransaction(	2✔
UNCOV 118	approveArgs: ApproveArgs,	×
UNCOV 119	tokenParams: TokenParams	×
UNCOV 120	): Promise<PopulatedTransaction> {	×
UNCOV 121	return new ERC20(tokenParams).buildApproveTransaction(approveArgs)	×
UNCOV 122	}	×
123		2✔
124	export async function balanceOf(	2✔
UNCOV 125	address: string,	×
UNCOV 126	tokenParams: TokenParams	×
UNCOV 127	): Promise<BigNumber> {	×
UNCOV 128	return new ERC20(tokenParams).balanceOf(address)	×
UNCOV 129	}	×
130		2✔
131	export async function allowanceOf(	2✔
UNCOV 132	owner: string,	×
UNCOV 133	spender: string,	×
UNCOV 134	tokenParams: TokenParams	×
UNCOV 135	): Promise<BigNumber> {	×
UNCOV 136	return new ERC20(tokenParams).allowanceOf(owner, spender)	×
UNCOV 137	}	×

synapsecns / sdk / 2591655167

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous