1984037718

Build # 1984037718

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/synapsecns/sdk/commit/<a class=hub.com/synapsecns/sdk/commit/f86721fa5a02e1d17594faee45b08269207ebb02">f86721fa5<a href="https://github.com/synapsecns/sdk/commit/f86721fa5a02e1d17594faee45b08269207ebb02">">Merge </a><a class="double-link" href="https://github.com/synapsecns/sdk/commit/<a class="double-link" href="https://github.com/synapsecns/sdk/commit/36701ec6feb48455228bdba8fee35bb323f04626">36701ec6f</a>">36701ec6f</a><a href="https://github.com/synapsecns/sdk/commit/f86721fa5a02e1d17594faee45b08269207ebb02"> into 724a4d903">724a4d903</a>

Pull Request Pull Request #74: Terra integration

Run Details

573 of 593 branches covered (96.63%)

Branch coverage included in aggregate %.

1097 of 1108 new or added lines in 22 files covered. (99.01%)

26 existing lines in 3 files now uncovered.

13470 of 13533 relevant lines covered (99.53%)

49.71 hits per line

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

91.43

/src/common/utils.ts

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

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

import {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 const rejectPromise = (e: any): Promise<never> => 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)
}

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 {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 const rejectPromise = (e: any): Promise<never> => 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✔
30	populatedTxn: Resolveable<PopulatedTransaction>,	14✔
31	signer: Signer,	14✔
32	successFn?: (result: BytesLike, tx?: {data: string, value?: BigNumberish}) => boolean	14✔
33	): Promise<StaticCallResult> {	14✔
34	return Promise.resolve(populatedTxn)	14✔
35	.then(txn => signer.call(txn)	14✔
36	.then((res): number => {	14✔
37	let successRes = StaticCallResult.Success;	2✔
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✔
48		2✔
49	return successRes	2✔
50	})	14✔
51	.catch((err) => {	14✔
52	// console.error(err);	12✔
53	return StaticCallResult.Failure	12✔
54	})	14✔
55	)	14✔
56	.catch(rejectPromise)	14✔
57	}	14✔
58		2✔
59	export function contractAddressFor(chainId: number, key: string): string {	2✔
60	const { address } = contractsForChainId(chainId)[key] \|\| "";	3,224!
61	return address	3,224✔
62	}	3,224✔
63		2✔
64		2✔
65	const CHAINID_CONTRACTS_MAP: {[c: number]: SynapseContracts.SynapseContract} = {	2✔
66	[ChainId.ETH]: SynapseContracts.Ethereum,	2✔
67	[ChainId.OPTIMISM]: SynapseContracts.Optimism,	2✔
68	[ChainId.CRONOS]: SynapseContracts.Cronos,	2✔
69	[ChainId.BSC]: SynapseContracts.BSC,	2✔
70	[ChainId.POLYGON]: SynapseContracts.Polygon,	2✔
71	[ChainId.FANTOM]: SynapseContracts.Fantom,	2✔
72	[ChainId.BOBA]: SynapseContracts.Boba,	2✔
73	[ChainId.METIS]: SynapseContracts.Metis,	2✔
74	[ChainId.MOONBEAM]: SynapseContracts.Moonbeam,	2✔
75	[ChainId.MOONRIVER]: SynapseContracts.Moonriver,	2✔
76	[ChainId.ARBITRUM]: SynapseContracts.Arbitrum,	2✔
77	[ChainId.AVALANCHE]: SynapseContracts.Avalanche,	2✔
78	[ChainId.TERRA]: SynapseContracts.Terra,	2✔
79	[ChainId.AURORA]: SynapseContracts.Aurora,	2✔
80	[ChainId.HARMONY]: SynapseContracts.Harmony,	2✔
81	}	2✔
82		2✔
83	export const contractsForChainId = (chainId: number): SynapseContracts.SynapseContract => CHAINID_CONTRACTS_MAP[chainId] ?? null	2!
84		2✔
85	export function decodeHexTerraAddress(hexAddr: string): string {	2✔
86	let addrAsBytes: number[] = [];	4✔
87	arrayify(hexAddr).forEach(b => addrAsBytes.push(b));	4✔
88		4✔
89	return bech32.encode("terra", addrAsBytes);	4✔
90	}	4✔

synapsecns / sdk / 1984037718

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