2034315063

Build # 2034315063

Build Type

github

Committed by GitHub

Commit Message

Merge 062f994c9 into b444b1589

Pull Request Pull Request #74: Terra integration

Run Details

606 of 646 branches covered (93.81%)

Branch coverage included in aggregate %.

459 of 727 new or added lines in 16 files covered. (63.14%)

196 existing lines in 7 files now uncovered.

13285 of 13768 relevant lines covered (96.49%)

17.07 hits per line

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

71.67

/src/common/utils.ts

import {ChainId}          from "@chainid";
import {SynapseContracts} from "./synapse_contracts";

import {
    GenericSigner,
    Resolveable,
    GenericTxnRequest,
    GenericTxnResponse,
    StaticCallResult,
} from "./types";

import {BigNumber, BigNumberish} from "@ethersproject/bignumber";
import {arrayify, BytesLike} from "@ethersproject/bytes";
import type {Signer}  from "@ethersproject/abstract-signer";
import type {PopulatedTransaction} from "@ethersproject/contracts";
import bech32 from "bech32";

export function rejectPromise(e: any): Promise<never> { return Promise.reject(e instanceof Error ? e : new Error(e)) }

export function executePopulatedTransaction(
    populatedTxn: GenericTxnRequest,
    signer:       GenericSigner,
): Promise<GenericTxnResponse> {
    return Promise.resolve(populatedTxn)
        .then(txn => signer.sendTransaction(txn))
        .catch(rejectPromise)
}

export function staticCallPopulatedTransaction(
    populatedTxn: Resolveable<PopulatedTransaction>,
    signer:       Signer,
    successFn?:   (result: BytesLike, tx?: {data: string, value?: BigNumberish}) => boolean
): Promise<StaticCallResult> {
    return Promise.resolve(populatedTxn)
        .then(txn => signer.call(txn)
            .then((res): number  => {
                let successRes = StaticCallResult.Success;
                /* c8 ignore start */
                if (successFn && (txn.data && txn.data !== "0x")) {
                    try {
                        let {data="", value} = txn;
                        successRes = successFn(res, {data, value})
                            ? StaticCallResult.Success
                            : StaticCallResult.Failure
                    } catch {}
                }
                /* c8 ignore stop */

                return successRes
        })
            .catch((err) => {
                // console.error(err);
                return StaticCallResult.Failure
            })
        )
        .catch(rejectPromise)
}

function pow10(exp: number): BigNumber { return BigNumber.from(10).pow(exp) }

/**
 * "Fixes" a value into units of Wei; should be used when tokens
 * have a decimals value which isn't 18
 * (such as USDC/USDT on chains which aren't BSC) and you need to do
 * calculations using proper units of Wei instead of, for example in the case of
 * USDC/USDT, Szabo (10^-6)
 * @param amt
 * @param decimals
 */
export function fixWeiValue(amt: BigNumber, decimals: number): BigNumber {
    const multiplier = pow10(18).div(pow10(decimals))
    return amt.mul(multiplier)
}

export function contractAddressFor(chainId: number, key: string): string {
    const { address } = contractsForChainId(chainId)[key] || "";
    return address
}


const CHAINID_CONTRACTS_MAP: {[c: number]: SynapseContracts.SynapseContract} = {
    [ChainId.ETH]:       SynapseContracts.Ethereum,
    [ChainId.OPTIMISM]:  SynapseContracts.Optimism,
    [ChainId.CRONOS]:    SynapseContracts.Cronos,
    [ChainId.BSC]:       SynapseContracts.BSC,
    [ChainId.POLYGON]:   SynapseContracts.Polygon,
    [ChainId.FANTOM]:    SynapseContracts.Fantom,
    [ChainId.BOBA]:      SynapseContracts.Boba,
    [ChainId.METIS]:     SynapseContracts.Metis,
    [ChainId.MOONBEAM]:  SynapseContracts.Moonbeam,
    [ChainId.MOONRIVER]: SynapseContracts.Moonriver,
    [ChainId.ARBITRUM]:  SynapseContracts.Arbitrum,
    [ChainId.AVALANCHE]: SynapseContracts.Avalanche,
    [ChainId.TERRA]:     SynapseContracts.Terra,
    [ChainId.AURORA]:    SynapseContracts.Aurora,
    [ChainId.HARMONY]:   SynapseContracts.Harmony,
}

export const contractsForChainId = (chainId: number): SynapseContracts.SynapseContract => CHAINID_CONTRACTS_MAP[chainId] ?? null


export function decodeHexTerraAddress(hexAddr: string): string {
    let addrAsBytes: number[] = [];
    arrayify(hexAddr).forEach(b => addrAsBytes.push(b));

    return bech32.encode("terra", addrAsBytes);
}

1	import {ChainId} from "@chainid";	2✔
2	import {SynapseContracts} from "./synapse_contracts";	2✔
3		2✔
4	import {	2✔
5	GenericSigner,	2✔
6	Resolveable,	2✔
7	GenericTxnRequest,	2✔
8	GenericTxnResponse,	2✔
9	StaticCallResult,	2✔
10	} from "./types";	2✔
11		2✔
12	import {BigNumber, BigNumberish} from "@ethersproject/bignumber";	2✔
13	import {arrayify, BytesLike} from "@ethersproject/bytes";	2✔
14	import type {Signer} from "@ethersproject/abstract-signer";	2✔
15	import type {PopulatedTransaction} from "@ethersproject/contracts";	2✔
16	import bech32 from "bech32";	2✔
17		2✔
18	export function rejectPromise(e: any): Promise<never> { return Promise.reject(e instanceof Error ? e : new Error(e)) }	2✔
19		2✔
20	export function executePopulatedTransaction(	2✔
NEW 21	populatedTxn: GenericTxnRequest,	×
NEW 22	signer: GenericSigner,	×
NEW 23	): Promise<GenericTxnResponse> {	×
UNCOV 24	return Promise.resolve(populatedTxn)	×
UNCOV 25	.then(txn => signer.sendTransaction(txn))	×
UNCOV 26	.catch(rejectPromise)	×
UNCOV 27	}	×
28		2✔
29	export function staticCallPopulatedTransaction(	2✔
UNCOV 30	populatedTxn: Resolveable<PopulatedTransaction>,	×
NEW 31	signer: Signer,	×
NEW 32	successFn?: (result: BytesLike, tx?: {data: string, value?: BigNumberish}) => boolean	×
UNCOV 33	): Promise<StaticCallResult> {	×
UNCOV 34	return Promise.resolve(populatedTxn)	×
NEW 35	.then(txn => signer.call(txn)	×
NEW 36	.then((res): number => {	×
NEW 37	let successRes = StaticCallResult.Success;	×
38	/* c8 ignore start */	2✔
39	if (successFn && (txn.data && txn.data !== "0x")) {	2✔
40	try {	2✔
41	let {data="", value} = txn;	2✔
42	successRes = successFn(res, {data, value})	2✔
43	? StaticCallResult.Success	2✔
44	: StaticCallResult.Failure	2✔
45	} catch {}	2✔
46	}	2✔
47	/* c8 ignore stop */	2✔
NEW 48		×
NEW 49	return successRes	×
UNCOV 50	})	×
NEW 51	.catch((err) => {	×
NEW 52	// console.error(err);	×
NEW 53	return StaticCallResult.Failure	×
NEW 54	})	×
NEW 55	)	×
NEW 56	.catch(rejectPromise)	×
UNCOV 57	}	×
58		2✔
59	function pow10(exp: number): BigNumber { return BigNumber.from(10).pow(exp) }	10✔
60		2✔
61	/**	2✔
62	* "Fixes" a value into units of Wei; should be used when tokens	2✔
63	* have a decimals value which isn't 18	2✔
64	* (such as USDC/USDT on chains which aren't BSC) and you need to do	2✔
65	* calculations using proper units of Wei instead of, for example in the case of	2✔
66	* USDC/USDT, Szabo (10^-6)	2✔
67	* @param amt	2✔
68	* @param decimals	2✔
69	*/	2✔
70	export function fixWeiValue(amt: BigNumber, decimals: number): BigNumber {	2✔
71	const multiplier = pow10(18).div(pow10(decimals))	5✔
72	return amt.mul(multiplier)	5✔
73	}	5✔
74		2✔
75	export function contractAddressFor(chainId: number, key: string): string {	2✔
76	const { address } = contractsForChainId(chainId)[key] \|\| "";	928!
77	return address	928✔
78	}	928✔
79		2✔
80		2✔
81	const CHAINID_CONTRACTS_MAP: {[c: number]: SynapseContracts.SynapseContract} = {	2✔
82	[ChainId.ETH]: SynapseContracts.Ethereum,	2✔
83	[ChainId.OPTIMISM]: SynapseContracts.Optimism,	2✔
84	[ChainId.CRONOS]: SynapseContracts.Cronos,	2✔
85	[ChainId.BSC]: SynapseContracts.BSC,	2✔
86	[ChainId.POLYGON]: SynapseContracts.Polygon,	2✔
87	[ChainId.FANTOM]: SynapseContracts.Fantom,	2✔
88	[ChainId.BOBA]: SynapseContracts.Boba,	2✔
89	[ChainId.METIS]: SynapseContracts.Metis,	2✔
90	[ChainId.MOONBEAM]: SynapseContracts.Moonbeam,	2✔
91	[ChainId.MOONRIVER]: SynapseContracts.Moonriver,	2✔
92	[ChainId.ARBITRUM]: SynapseContracts.Arbitrum,	2✔
93	[ChainId.AVALANCHE]: SynapseContracts.Avalanche,	2✔
94	[ChainId.TERRA]: SynapseContracts.Terra,	2✔
95	[ChainId.AURORA]: SynapseContracts.Aurora,	2✔
96	[ChainId.HARMONY]: SynapseContracts.Harmony,	2✔
97	}	2✔
98		2✔
99	export const contractsForChainId = (chainId: number): SynapseContracts.SynapseContract => CHAINID_CONTRACTS_MAP[chainId] ?? null	2!
100		2✔
101		2✔
102	export function decodeHexTerraAddress(hexAddr: string): string {	2✔
NEW 103	let addrAsBytes: number[] = [];	×
NEW 104	arrayify(hexAddr).forEach(b => addrAsBytes.push(b));	×
NEW 105		×
NEW 106	return bech32.encode("terra", addrAsBytes);	×
NEW 107	}	×

synapsecns / sdk / 2034315063

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