diff --git a/packages/currency/src/aggregators/goerli.json b/packages/currency/src/aggregators/goerli.json new file mode 100644 index 0000000000..93d71cbd2c --- /dev/null +++ b/packages/currency/src/aggregators/goerli.json @@ -0,0 +1,8 @@ +{ + "0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc": { + "0x775eb53d00dd0acd3ec1696472105d579b9b386b": 1 + }, + "0x775eb53d00dd0acd3ec1696472105d579b9b386b": { + "0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc": 1 + } +} diff --git a/packages/currency/src/erc20/networks/goerli.ts b/packages/currency/src/erc20/networks/goerli.ts new file mode 100644 index 0000000000..d890fe3c30 --- /dev/null +++ b/packages/currency/src/erc20/networks/goerli.ts @@ -0,0 +1,17 @@ +import { TokenMap } from './types'; + +// List of the supported goerli ERC20 tokens +export const supportedGoerliERC20: TokenMap = { + // Request Test token, used for testing on goerli. + '0x7af963cF6D228E564e2A0aA0DdBF06210B38615D': { + decimals: 18, + name: 'Goerli Test Token', + symbol: 'TST', + }, + // Faucet Token on goerli network. Easy to use on tests. + '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc': { + decimals: 18, + name: 'Faucet Token', + symbol: 'FAU-goerli', + }, +}; diff --git a/packages/payment-detection/src/erc20/address-based.ts b/packages/payment-detection/src/erc20/address-based.ts index 5bd11e632e..4664b3164f 100644 --- a/packages/payment-detection/src/erc20/address-based.ts +++ b/packages/payment-detection/src/erc20/address-based.ts @@ -8,7 +8,7 @@ import { BalanceError } from '../balance-error'; import Erc20InfoRetriever from './address-based-info-retriever'; import { PaymentDetectorBase } from '../payment-detector-base'; -const supportedNetworks = ['mainnet', 'rinkeby', 'private']; +const supportedNetworks = ['mainnet', 'rinkeby', 'goerli', 'private']; /** * Handle payment networks with ERC20 based address extension diff --git a/packages/payment-detection/test/any/any-to-erc20-proxy-contract.test.ts b/packages/payment-detection/test/any/any-to-erc20-proxy-contract.test.ts index 1be024d556..2acfa670b2 100644 --- a/packages/payment-detection/test/any/any-to-erc20-proxy-contract.test.ts +++ b/packages/payment-detection/test/any/any-to-erc20-proxy-contract.test.ts @@ -31,7 +31,7 @@ const mockAdvancedLogic: AdvancedLogicTypes.IAdvancedLogic = { }, extensions: { anyToErc20Proxy: { - supportedNetworks: ['mainnet', 'rinkeby', 'private'], + supportedNetworks: ['mainnet', 'rinkeby', 'goerli', 'private'], createAddPaymentAddressAction, createAddRefundAddressAction, createCreationAction, @@ -56,7 +56,7 @@ describe('api/any/conversion-fee-proxy-contract', () => { jest.clearAllMocks(); }); - it('can createExtensionsDataForCreation', async () => { + it('can createExtensionsDataForCreation (Rinkeby)', async () => { await anyToErc20Proxy.createExtensionsDataForCreation({ paymentAddress: 'ethereum address', salt: 'ea3bc7caf64110ca', @@ -77,7 +77,28 @@ describe('api/any/conversion-fee-proxy-contract', () => { }); }); - it('can createExtensionsDataForCreation with fee amount and address', async () => { + it('can createExtensionsDataForCreation (Goerli)', async () => { + await anyToErc20Proxy.createExtensionsDataForCreation({ + paymentAddress: 'ethereum address', + salt: 'ea3bc7caf64110ca', + acceptedTokens: ['ethereum address2'], + network: 'goerli', + maxRateTimespan: 1000, + }); + + expect(createCreationAction).toHaveBeenCalledWith({ + feeAddress: undefined, + feeAmount: undefined, + paymentAddress: 'ethereum address', + refundAddress: undefined, + salt: 'ea3bc7caf64110ca', + acceptedTokens: ['ethereum address2'], + network: 'goerli', + maxRateTimespan: 1000, + }); + }); + + it('can createExtensionsDataForCreation with fee amount and address (Rinkeby)', async () => { await anyToErc20Proxy.createExtensionsDataForCreation({ feeAddress: 'fee address', feeAmount: '2000', @@ -98,6 +119,27 @@ describe('api/any/conversion-fee-proxy-contract', () => { }); }); + it('can createExtensionsDataForCreation with fee amount and address (Goerli)', async () => { + await anyToErc20Proxy.createExtensionsDataForCreation({ + feeAddress: 'fee address', + feeAmount: '2000', + paymentAddress: 'ethereum address', + salt: 'ea3bc7caf64110ca', + acceptedTokens: ['ethereum address2'], + network: 'goerli', + }); + + expect(createCreationAction).toHaveBeenCalledWith({ + feeAddress: 'fee address', + feeAmount: '2000', + paymentAddress: 'ethereum address', + refundAddress: undefined, + salt: 'ea3bc7caf64110ca', + acceptedTokens: ['ethereum address2'], + network: 'goerli', + }); + }); + it('can createExtensionsDataForCreation without salt', async () => { await anyToErc20Proxy.createExtensionsDataForCreation({ paymentAddress: 'ethereum address', diff --git a/packages/payment-detection/test/erc20/address-based.test.ts b/packages/payment-detection/test/erc20/address-based.test.ts index f75629d334..93fa533021 100644 --- a/packages/payment-detection/test/erc20/address-based.test.ts +++ b/packages/payment-detection/test/erc20/address-based.test.ts @@ -126,7 +126,7 @@ describe('api/erc20/address-based', () => { error: { code: PaymentTypes.BALANCE_ERROR_CODE.NETWORK_NOT_SUPPORTED, message: - 'Payment network wrong not supported by ERC20 payment detection. Supported networks: mainnet, rinkeby, private', + 'Payment network wrong not supported by ERC20 payment detection. Supported networks: mainnet, rinkeby, goerli, private', }, events: [], }); diff --git a/packages/payment-detection/test/erc20/escrow-info-retriever.test.ts b/packages/payment-detection/test/erc20/escrow-info-retriever.test.ts index 53a6246639..cc6aeb2ad4 100644 --- a/packages/payment-detection/test/erc20/escrow-info-retriever.test.ts +++ b/packages/payment-detection/test/erc20/escrow-info-retriever.test.ts @@ -161,4 +161,28 @@ describe('api/erc20/escrow-info-retriever', () => { expect(escrowChainData.isFrozen).toEqual(true); }); }); + + describe('test on goerli', () => { + let infoRetriever: EscrowERC20InfoRetriever; + beforeAll(() => { + infoRetriever = new EscrowERC20InfoRetriever( + paymentReferenceMock, + '0xd2777001fD7D89331D8E87eC439f78079179322b', + 0, + '', + '', + 'goerli', + ); + }); + it('should get escrow chain data', async () => { + const escrowChainData = await infoRetriever.getEscrowRequestMapping(); + // Not yet ERC777 token on goerli + expect(escrowChainData.payer).toEqual('0xffb1D8EfeCAA177DeEf1cD1AB202E5E9f6a84db4'); + expect(escrowChainData.amount.toString()).toEqual('1'); + expect(escrowChainData.unlockDate.toString()).toEqual('0'); + expect(escrowChainData.emergencyClaimDate.toString()).toEqual('0'); + expect(escrowChainData.emergencyState).toEqual(false); + expect(escrowChainData.isFrozen).toEqual(false); + }); + }); }); diff --git a/packages/payment-detection/test/erc20/fee-proxy-contract.test.ts b/packages/payment-detection/test/erc20/fee-proxy-contract.test.ts index f7504c9b8d..c0d924c21d 100644 --- a/packages/payment-detection/test/erc20/fee-proxy-contract.test.ts +++ b/packages/payment-detection/test/erc20/fee-proxy-contract.test.ts @@ -23,7 +23,7 @@ const mockAdvancedLogic: AdvancedLogicTypes.IAdvancedLogic = { }, extensions: { feeProxyContractErc20: { - supportedNetworks: ['mainnet', 'private', 'rinkeby'], + supportedNetworks: ['mainnet', 'private', 'rinkeby', 'goerli'], createAddPaymentAddressAction, createAddRefundAddressAction, createCreationAction, @@ -283,7 +283,7 @@ describe('api/erc20/fee-proxy-contract', () => { ).toBe('7'); }); - it('should have gasFee & gasUsed in the payment eventl', async () => { + it('should have gasFee & gasUsed in the payment event', async () => { const mockRequest: RequestLogicTypes.IRequest = { creator: { type: IdentityTypes.TYPE.ETHEREUM_ADDRESS, value: '0x2' }, currency: { diff --git a/packages/payment-detection/test/erc20/proxy-contract.test.ts b/packages/payment-detection/test/erc20/proxy-contract.test.ts index 5d89bb7977..f814c0ae58 100644 --- a/packages/payment-detection/test/erc20/proxy-contract.test.ts +++ b/packages/payment-detection/test/erc20/proxy-contract.test.ts @@ -25,7 +25,7 @@ const mockAdvancedLogic: AdvancedLogicTypes.IAdvancedLogic = { }, extensions: { proxyContractErc20: { - supportedNetworks: ['mainnet', 'rinkeby'], + supportedNetworks: ['mainnet', 'rinkeby', 'goerli'], createAddPaymentAddressAction, createAddRefundAddressAction, createCreationAction, @@ -160,7 +160,7 @@ describe('api/erc20/proxy-contract', () => { error: { code: PaymentTypes.BALANCE_ERROR_CODE.NETWORK_NOT_SUPPORTED, message: - 'Payment network WRONG not supported by pn-erc20-proxy-contract payment detection. Supported networks: mainnet, rinkeby', + 'Payment network WRONG not supported by pn-erc20-proxy-contract payment detection. Supported networks: mainnet, rinkeby, goerli', }, events: [], }); diff --git a/packages/payment-detection/test/erc20/thegraph-info-retriever.test.ts b/packages/payment-detection/test/erc20/thegraph-info-retriever.test.ts index 7c13df6b72..a9af030300 100644 --- a/packages/payment-detection/test/erc20/thegraph-info-retriever.test.ts +++ b/packages/payment-detection/test/erc20/thegraph-info-retriever.test.ts @@ -51,7 +51,7 @@ describe('api/erc20/thegraph-info-retriever', () => { expect(transferEvents[0].parameters?.feeAmount).toEqual(paymentData.feeAmount); }); - it('should get payment event from ethFeeConversionProxy via subgraph', async () => { + it('should get payment event from ethFeeConversionProxy via subgraph (Rinkeby)', async () => { const paymentData = { reference: '0x6c93723bc5f82e6fbb2ea994bf0fb572fa19f7a2a3146065e21752b95668efe5', txHash: '0x2f7b4752aa259166c038cd9073056c5979760cf0eea55d093fca2095c229313b', @@ -89,4 +89,90 @@ describe('api/erc20/thegraph-info-retriever', () => { expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); }); }); + + describe('on goerli', () => { + const GOERLI_ETH_FEE_PROXY_CONTRACT = '0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687'; + const GOERLI_ETH_CONVERSION_PROXY_CONTRACT = '0xED250D9219EB93098Bb67aEbc992963172B9c8DA'; + + it('should get payment event from ethFeeProxy via subgraph', async () => { + const paymentData = { + reference: '0x6c93723bc5f82e6fbb2ea994bf0fb572fa19f7a2a3146065e21752b95668efe5', + txHash: '0x29a55b7f978a902275746f6eb930abf608dc77c0592fce9cf6c326128fcf7493', + from: '0xBc9643B7Bd7c8621F4a68280433796484b9E525d', + to: '0x5000ee9fb9c96a2a09d8efb695ac21d6c429ff11', + network: 'goerli', + salt: '0ee84db293a752c6', + amount: '600000000000000', + requestId: '0188791633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f173c7a4e3ce7e1', + block: 7230236, + feeAddress: '0x5000EE9FB9c96A2A09D8efB695aC21D6C429fF11', + feeAmount: '0', + }; + const paymentReference = PaymentReferenceCalculator.calculate( + paymentData.requestId, + paymentData.salt, + paymentData.to, + ); + const onChainReference = utils.keccak256(`0x${paymentReference}`); + expect(onChainReference).toEqual(paymentData.reference); + + const graphRetriever = new TheGraphInfoRetriever( + paymentReference, + GOERLI_ETH_FEE_PROXY_CONTRACT, + null, + paymentData.to, + PaymentTypes.EVENTS_NAMES.PAYMENT, + paymentData.network, + ); + const allNetworkEvents = await graphRetriever.getTransferEvents(); + const transferEvents = allNetworkEvents.paymentEvents; + // expect(transferEvents).toHaveLength(1); + expect(transferEvents[0].amount).toEqual('600000000000000'); + expect(transferEvents[0].name).toEqual('payment'); + expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); + expect(transferEvents[0].parameters?.txHash).toEqual(paymentData.txHash); + expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); + expect(transferEvents[0].parameters?.feeAddress).toEqual(paymentData.feeAddress); + expect(transferEvents[0].parameters?.feeAmount).toEqual(paymentData.feeAmount); + }); + + // doesn't work because chainlink doesn't have oracles on goerli + it.skip('should get payment event from ethFeeConversionProxy via subgraph', async () => { + const paymentData = { + reference: '0x6c93723bc5f82e6fbb2ea994bf0fb572fa19f7a2a3146065e21752b95668efe5', + txHash: '0x2f7b4752aa259166c038cd9073056c5979760cf0eea55d093fca2095c229313b', + from: '0x186e7fe6c34ea0eca7f9c2fd29651fc0443e3f29', + to: '0x5000ee9fb9c96a2a09d8efb695ac21d6c429ff11', + network: 'goerli', + salt: '0ee84db293a752c6', + amount: '7000', + block: 9610470, + requestId: '0188791633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f173c7a4e3ce7e1', + }; + + const shortReference = PaymentReferenceCalculator.calculate( + paymentData.requestId, + paymentData.salt, + paymentData.to, + ); + const onChainReference = utils.keccak256(`0x${shortReference}`); + expect(onChainReference).toEqual(paymentData.reference); + + const graphRetriever = new TheGraphInfoRetriever( + shortReference, + GOERLI_ETH_CONVERSION_PROXY_CONTRACT, + null, + paymentData.to, + PaymentTypes.EVENTS_NAMES.PAYMENT, + paymentData.network, + ); + const allNetworkEvents = await graphRetriever.getTransferEvents(); + const transferEvents = allNetworkEvents.paymentEvents; + // expect(transferEvents).toHaveLength(1); + expect(transferEvents[0].amount).toEqual(paymentData.amount); + expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); + expect(transferEvents[0].parameters?.txHash).toEqual(paymentData.txHash); + expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); + }); + }); }); diff --git a/packages/payment-detection/test/erc777/mocks.ts b/packages/payment-detection/test/erc777/mocks.ts index 69565f307f..8cfdc6eb5c 100644 --- a/packages/payment-detection/test/erc777/mocks.ts +++ b/packages/payment-detection/test/erc777/mocks.ts @@ -76,7 +76,7 @@ const mockFlows = [ }, { transactionHash: '0xe472ca1b52751b058fbdaeaffebd98c0cc43b45aa31794b3eb06834ede19f7be', - blockNumber: '9945543', + blockNumber: 9945543, timestamp: '1641495767', sender: '0x9c040e2d6fd83a8b35069aa7154b69674961e0f7', flowRate: '0', diff --git a/packages/payment-detection/test/erc777/superfluid-retriever.test.ts b/packages/payment-detection/test/erc777/superfluid-retriever.test.ts index 9ea56eb5e9..6d9e74f63e 100644 --- a/packages/payment-detection/test/erc777/superfluid-retriever.test.ts +++ b/packages/payment-detection/test/erc777/superfluid-retriever.test.ts @@ -10,7 +10,7 @@ const graphql = mocked(GraphQLClient.prototype); describe('api/erc777/superfluid-info-retriever', () => { describe('on untagged requests', () => { - it('should get payment events from SuperFluid via subgraph with 1 request', async () => { + it('should get payment events from SuperFluid via subgraph with 1 request (Rinkeby)', async () => { const paymentData = { reference: '0xbeefaccc470c7dbd54de69', txHash: '0xe472ca1b52751b058fbdaeaffebd98c0cc43b45aa31794b3eb06834ede19f7be', @@ -50,10 +50,51 @@ describe('api/erc777/superfluid-info-retriever', () => { expect(transferEvents[0].parameters?.txHash).toEqual(paymentData.txHash); expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); }); + + it('should get payment events from SuperFluid via subgraph with 1 request (Goerli)', async () => { + const paymentData = { + reference: '0xbeefaccc470c7dbd54de69', + txHash: '0xe472ca1b52751b058fbdaeaffebd98c0cc43b45aa31794b3eb06834ede19f7be', + from: '0x9c040e2d6fd83a8b35069aa7154b69674961e0f7', + to: '0x52e5bcfa46393894afcfe6cd98a6761fa692c594', + network: 'goerli', + salt: '0ee84db293a752c6', + amount: '92592592592592000', + requestId: '0188791633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f173c7a4e3ce7e1', + block: 9945543, + token: '0x2bf02814ea0b2b155ed47b7cede18caa752940e6', //fDAIx + }; + graphql.request.mockResolvedValue(mockSuperfluidSubgraph[0]); + + const paymentReference = PaymentReferenceCalculator.calculate( + paymentData.requestId, + paymentData.salt, + paymentData.to, + ); + const subgraphReference = `0xbeefac${paymentReference}`; + expect(subgraphReference).toEqual(paymentData.reference); + + const graphRetriever = new SuperFluidInfoRetriever( + paymentReference, + paymentData.token, + paymentData.to, + PaymentTypes.EVENTS_NAMES.PAYMENT, + paymentData.network, + ); + const transferEvents = await graphRetriever.getTransferEvents(); + expect(transferEvents).toHaveLength(5); + expect(transferEvents[0].amount).toEqual(paymentData.amount); + expect(transferEvents[0].name).toEqual('payment'); + expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); + expect(transferEvents[1].amount).toEqual('34722222222222000'); + expect(transferEvents[2].amount).toEqual('40509259259259000'); + expect(transferEvents[0].parameters?.txHash).toEqual(paymentData.txHash); + expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); + }); }); describe('on 2 nested requests', () => { - it('should get payment event from SuperFluid via subgraph with 2 requests', async () => { + it('should get payment event from SuperFluid via subgraph with 2 requests (Rinkeby)', async () => { const paymentData = { reference: '0xbeefac9474ad7670909da5', from: '0x9c040e2d6fd83a8b35069aa7154b69674961e0f7', @@ -64,8 +105,6 @@ describe('api/erc777/superfluid-info-retriever', () => { // = (1642693617 - 1642692777 = 840 sec) x (385802469135800 - 3858024691358 = 381944444444442 Wei DAIx / sec) requestId: '0288792633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f273c7a4e3ce7e2', token: '0x745861aed1eee363b4aaa5f1994be40b1e05ff90', //fDAIx - block: 10024811, - txHash: '0x0fefa02d90be46eb51a82f02b7a787084c35a895bd833a7c9f0560e315bb4061', }; graphql.request.mockResolvedValue(mockSuperfluidSubgraph[1]); @@ -88,13 +127,46 @@ describe('api/erc777/superfluid-info-retriever', () => { expect(transferEvents[0].amount).toEqual(paymentData.amount); expect(transferEvents[0].name).toEqual('payment'); expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); - expect(transferEvents[0].parameters?.txHash).toEqual(paymentData.txHash); - expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); + }); + + it('should get payment event from SuperFluid via subgraph with 2 requests (Goerli)', async () => { + const paymentData = { + reference: '0xbeefac9474ad7670909da5', + from: '0x9c040e2d6fd83a8b35069aa7154b69674961e0f7', + to: '0x52e5bcfa46393894afcfe6cd98a6761fa692c594', + network: 'goerli', + salt: '0ee84db293a752c6', + amount: '320833333333331260', + // = (1642693617 - 1642692777 = 840 sec) x (385802469135800 - 3858024691358 = 381944444444442 Wei DAIx / sec) + requestId: '0288792633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f273c7a4e3ce7e2', + token: '0x2bf02814ea0b2b155ed47b7cede18caa752940e6', //fDAIx + }; + graphql.request.mockResolvedValue(mockSuperfluidSubgraph[1]); + + const paymentReference = PaymentReferenceCalculator.calculate( + paymentData.requestId, + paymentData.salt, + paymentData.to, + ); + const subgraphReference = `0xbeefac${paymentReference}`; + expect(subgraphReference).toEqual(paymentData.reference); + const graphRetriever = new SuperFluidInfoRetriever( + paymentReference, + paymentData.token, + paymentData.to, + PaymentTypes.EVENTS_NAMES.PAYMENT, + paymentData.network, + ); + const transferEvents = await graphRetriever.getTransferEvents(); + expect(transferEvents).toHaveLength(1); + expect(transferEvents[0].amount).toEqual(paymentData.amount); + expect(transferEvents[0].name).toEqual('payment'); + expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); }); }); describe('on ongoing request', () => { - it('should get payment event from SuperFluid via subgraph with ongoing request', async () => { + it('should get payment event from SuperFluid via subgraph with ongoing request (Rinkeby)', async () => { const paymentData = { reference: '0xbeefac0e87b43bf1e99c82', from: '0x165a26628ac843e97f657e648b004226fbb7f7c5', @@ -105,8 +177,6 @@ describe('api/erc777/superfluid-info-retriever', () => { requestId: '0688792633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f273c7a4e3ce7e2', token: '0x0f1d7c55a2b133e000ea10eec03c774e0d6796e8', //fUSDCx timestamp: 1643041225, - block: 10047970, - txHash: '0xdb44f35aa1490d2ddc8bbe7b82e0e3a370f3bf171a55da7a8a5886996e9c468d', }; graphql.request.mockResolvedValue(mockSuperfluidSubgraph[2]); @@ -131,8 +201,43 @@ describe('api/erc777/superfluid-info-retriever', () => { expect(transferEvents[0].amount).toEqual(timestamp.toString()); expect(transferEvents[0].name).toEqual('payment'); expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); - expect(transferEvents[0].parameters?.txHash).toEqual(paymentData.txHash); - expect(transferEvents[0].parameters?.block).toEqual(paymentData.block); + }); + + it('should get payment event from SuperFluid via subgraph with ongoing request (Goerli)', async () => { + const paymentData = { + reference: '0xbeefac0e87b43bf1e99c82', + from: '0x165a26628ac843e97f657e648b004226fbb7f7c5', + to: '0xe7e6431f08db273d915b49888f0c67ef61802e05', + network: 'goerli', + salt: '0ee84db293a752c6', + amount: '1', + requestId: '0688792633ff0ec72a7dbdefb886d2db6cccfa98287320839c2f273c7a4e3ce7e2', + token: '0x2bf02814ea0b2b155ed47b7cede18caa752940e6', //fDaix + timestamp: 1643041225, + }; + graphql.request.mockResolvedValue(mockSuperfluidSubgraph[2]); + + const paymentReference = PaymentReferenceCalculator.calculate( + paymentData.requestId, + paymentData.salt, + paymentData.to, + ); + const subgraphReference = `0xbeefac${paymentReference}`; + expect(subgraphReference).toEqual(paymentData.reference); + const graphRetriever = new SuperFluidInfoRetriever( + paymentReference, + paymentData.token, + paymentData.to, + PaymentTypes.EVENTS_NAMES.PAYMENT, + paymentData.network, + ); + jest.spyOn(Date, 'now').mockImplementation(() => 1643126596704); + const transferEvents = await graphRetriever.getTransferEvents(); + const timestamp = Math.floor(Date.now() / 1000) - paymentData.timestamp; + expect(transferEvents).toHaveLength(1); + expect(transferEvents[0].amount).toEqual(timestamp.toString()); + expect(transferEvents[0].name).toEqual('payment'); + expect(transferEvents[0].parameters?.to).toEqual(paymentData.to); }); }); }); diff --git a/packages/payment-detection/test/eth/info-retriever.test.ts b/packages/payment-detection/test/eth/info-retriever.test.ts index 0a314c0c79..8a50bfddba 100644 --- a/packages/payment-detection/test/eth/info-retriever.test.ts +++ b/packages/payment-detection/test/eth/info-retriever.test.ts @@ -51,6 +51,7 @@ describe('api/eth/info-retriever', () => { [ 'mainnet', 'rinkeby', + // 'goerli', // 'xdai', // 'sokol', 'fuse', diff --git a/packages/payment-detection/test/eth/input-data.test.ts b/packages/payment-detection/test/eth/input-data.test.ts index 3be6bfd6db..054c189c16 100644 --- a/packages/payment-detection/test/eth/input-data.test.ts +++ b/packages/payment-detection/test/eth/input-data.test.ts @@ -23,7 +23,7 @@ const mockAdvancedLogic: AdvancedLogicTypes.IAdvancedLogic = { createAddPaymentAddressAction, createAddRefundAddressAction, createCreationAction, - supportedNetworks: ['mainnet', 'rinkeby'], + supportedNetworks: ['mainnet', 'rinkeby', 'goerli'], // inherited from declarative createAddPaymentInstructionAction, createAddRefundInstructionAction, @@ -160,7 +160,7 @@ describe('api/eth/input-data', () => { error: { code: PaymentTypes.BALANCE_ERROR_CODE.NETWORK_NOT_SUPPORTED, message: - /Payment network wrong not supported by ETH payment detection\. Supported networks: mainnet, rinkeby, private.*/, + /Payment network wrong not supported by ETH payment detection\. Supported networks: mainnet, rinkeby, goerli, private.*/, }, events: [], }); diff --git a/packages/payment-detection/test/provider.test.ts b/packages/payment-detection/test/provider.test.ts index 1a9fdaf5ff..1ffabb0b9d 100644 --- a/packages/payment-detection/test/provider.test.ts +++ b/packages/payment-detection/test/provider.test.ts @@ -14,13 +14,20 @@ describe('getDefaultProvider', () => { await expect(provider.getNetwork()).resolves.toMatchObject({ chainId: 1 }); }); - it('Can take a standard network', async () => { + it('Can take a standard network (Rinkeby)', async () => { const provider = getDefaultProvider('rinkeby'); expect(provider).toBeInstanceOf(providers.InfuraProvider); await expect(provider.getNetwork()).resolves.toMatchObject({ chainId: 4 }); }); + it('Can take a standard network (Goerli)', async () => { + const provider = getDefaultProvider('goerli'); + + expect(provider).toBeInstanceOf(providers.InfuraProvider); + await expect(provider.getNetwork()).resolves.toMatchObject({ chainId: 5 }); + }); + it('Can take a private network', async () => { const provider = getDefaultProvider('private') as providers.JsonRpcProvider; @@ -71,12 +78,16 @@ describe('getDefaultProvider', () => { ); }); - it('Can override the api key for a standard provider', async () => { - initPaymentDetectionApiKeys({ - infura: 'foo-bar', - }); + expect((getDefaultProvider('goerli') as providers.JsonRpcProvider).connection.url).toMatch( + /https:\/\/goerli\.infura.*/, + ); +}); - const provider = getDefaultProvider() as providers.InfuraProvider; - expect(provider.connection.url).toEqual('https://mainnet.infura.io/v3/foo-bar'); +it('Can override the api key for a standard provider', async () => { + initPaymentDetectionApiKeys({ + infura: 'foo-bar', }); + + const provider = getDefaultProvider() as providers.InfuraProvider; + expect(provider.connection.url).toEqual('https://mainnet.infura.io/v3/foo-bar'); }); diff --git a/packages/payment-processor/src/payment/utils.ts b/packages/payment-processor/src/payment/utils.ts index 355665d174..a0dc0b72df 100644 --- a/packages/payment-processor/src/payment/utils.ts +++ b/packages/payment-processor/src/payment/utils.ts @@ -30,7 +30,7 @@ export function getProvider(): providers.Web3Provider { /** * Utility to get a network provider, depending on the request's currency network. - * Will throw an error if the network isn't mainnet or rinkeby + * Will throw an error if the network isn't mainnet, rinkeby, or goerli * * @param request */ diff --git a/packages/payment-processor/test/payment/utils.test.ts b/packages/payment-processor/test/payment/utils.test.ts index 7f06a01d1e..16edf997d5 100644 --- a/packages/payment-processor/test/payment/utils.test.ts +++ b/packages/payment-processor/test/payment/utils.test.ts @@ -108,6 +108,15 @@ describe('getNetworkProvider', () => { expect(getNetworkProvider(request)).toBeInstanceOf(providers.Provider); }); + it('returns a provider for goerli', () => { + const request: any = { + currencyInfo: { + network: 'goerli', + }, + }; + expect(getNetworkProvider(request)).toBeInstanceOf(providers.Provider); + }); + it('fails for other network', () => { const request: any = { currencyInfo: { diff --git a/packages/smart-contracts/scripts-create2/constructor-args.ts b/packages/smart-contracts/scripts-create2/constructor-args.ts index db9d4952e6..58217038c8 100644 --- a/packages/smart-contracts/scripts-create2/constructor-args.ts +++ b/packages/smart-contracts/scripts-create2/constructor-args.ts @@ -22,7 +22,6 @@ export const getConstructorArgs = (contract: string, network?: string): string[] '0x0000000000000000000000000000000000000000', '0x39e19aa5b69466dfdc313c7cda37cb2a599015cd', ]; - // TODO setupETHConversionProxy } case 'ERC20SwapToConversion': { return [getAdminWalletAddress(contract)]; diff --git a/packages/smart-contracts/scripts-create2/contract-setup/setupETHConversionProxy.ts b/packages/smart-contracts/scripts-create2/contract-setup/setupETHConversionProxy.ts index 28d1c974d9..b0c0cbfee8 100644 --- a/packages/smart-contracts/scripts-create2/contract-setup/setupETHConversionProxy.ts +++ b/packages/smart-contracts/scripts-create2/contract-setup/setupETHConversionProxy.ts @@ -8,7 +8,7 @@ import { updateChainlinkConversionPath, updatePaymentErc20FeeProxy } from './adm * @param contractAddress address of the BatchPayments Proxy * @param hre Hardhat runtime environment */ -export const setupEthConversionProxy = async ( +export const setupETHConversionProxy = async ( contractAddress: string, hre: HardhatRuntimeEnvironmentExtended, ): Promise => { diff --git a/packages/smart-contracts/scripts-create2/contract-setup/setups.ts b/packages/smart-contracts/scripts-create2/contract-setup/setups.ts index 88f85e030b..cda45affa2 100644 --- a/packages/smart-contracts/scripts-create2/contract-setup/setups.ts +++ b/packages/smart-contracts/scripts-create2/contract-setup/setups.ts @@ -1,143 +1,10 @@ import { HardhatRuntimeEnvironmentExtended } from '../types'; -import { erc20SwapConversionArtifact } from '../../src/lib'; -import { batchPaymentsArtifact } from '../../src/lib'; -import utils from '@requestnetwork/utils'; -import { - updateBatchPaymentFees, - updatePaymentErc20FeeProxy, - updatePaymentEthFeeProxy, - updateChainlinkConversionPath, - updateRequestSwapFees, - updateSwapRouter, -} from './adminTasks'; +import { setupETHConversionProxy } from './setupETHConversionProxy'; +import { setupBatchPayments } from './setupBatchPayments'; +import { setupERC20SwapToConversion } from './setupERC20SwapToConversion'; /** - * Updates the values of the batch fees of the BatchPayments contract, if needed - * @param contractAddress address of the BatchPayments Proxy - * @param hre Hardhat runtime environment - */ -const setupBatchPayments = async ( - contractAddress: string, - hre: HardhatRuntimeEnvironmentExtended, -): Promise => { - // Setup contract parameters - const batchPaymentContract = new hre.ethers.Contract( - contractAddress, - batchPaymentsArtifact.getContractAbi(), - ); - await Promise.all( - hre.config.xdeploy.networks.map(async (network) => { - let provider; - if (network === 'celo') { - provider = utils.getCeloProvider(); - } else { - provider = utils.getDefaultProvider(network); - } - const wallet = new hre.ethers.Wallet(hre.config.xdeploy.signer, provider); - const signer = wallet.connect(provider); - const batchPaymentConnected = await batchPaymentContract.connect(signer); - const adminNonce = await signer.getTransactionCount(); - const gasPrice = await provider.getGasPrice(); - - // start from the adminNonce, increase gasPrice if needed - await Promise.all([ - updateBatchPaymentFees(batchPaymentConnected, adminNonce, gasPrice.mul(2)), - updatePaymentErc20FeeProxy(batchPaymentConnected, network, adminNonce + 1, gasPrice.mul(2)), - updatePaymentEthFeeProxy(batchPaymentConnected, network, adminNonce + 2, gasPrice.mul(2)), - ]); - }), - ); - console.log('Setup for setupBatchPayment successful'); -}; - -/** - * Updates the values of the chainlinkConversionPath and swap router of the ERC20SwapToConversion contract, if needed - * @param contractAddress address of the ERC20SwapToConversion Proxy - * @param hre Hardhat runtime environment - */ -const setupERC20SwapToConversion = async ( - contractAddress: string, - hre: HardhatRuntimeEnvironmentExtended, -): Promise => { - // Setup contract parameters - const ERC20SwapToConversionContract = new hre.ethers.Contract( - contractAddress, - erc20SwapConversionArtifact.getContractAbi(), - ); - await Promise.all( - hre.config.xdeploy.networks.map(async (network) => { - let provider; - if (network === 'celo') { - provider = utils.getCeloProvider(); - } else { - provider = utils.getDefaultProvider(network); - } - const wallet = new hre.ethers.Wallet(hre.config.xdeploy.signer, provider); - const signer = wallet.connect(provider); - const ERC20SwapToConversionConnected = await ERC20SwapToConversionContract.connect(signer); - const adminNonce = await signer.getTransactionCount(); - const gasPrice = await provider.getGasPrice(); - - await Promise.all([ - updateChainlinkConversionPath( - ERC20SwapToConversionConnected, - network, - adminNonce, - gasPrice, - ), - updateSwapRouter(ERC20SwapToConversionConnected, network, adminNonce + 1, gasPrice), - updateRequestSwapFees(ERC20SwapToConversionConnected, adminNonce + 2, gasPrice), - ]); - }), - ); - console.log('Setup for ERC20SwapToConversion successfull'); -}; - -/** - * Updates the values of the EthConversionProxy contract, if needed - * @param contractAddress address of the EthConversion Proxy - * @param hre Hardhat runtime environment - */ -const setupEthConversionProxy = async ( - contractAddress: string, - hre: HardhatRuntimeEnvironmentExtended, -): Promise => { - // Setup contract parameters - const EthConversionProxyContract = new hre.ethers.Contract( - contractAddress, - batchPaymentsArtifact.getContractAbi(), - ); - await Promise.all( - hre.config.xdeploy.networks.map(async (network) => { - let provider; - if (network === 'celo') { - provider = utils.getCeloProvider(); - } else { - provider = utils.getDefaultProvider(network); - } - const wallet = new hre.ethers.Wallet(hre.config.xdeploy.signer, provider); - const signer = wallet.connect(provider); - const EthConversionProxyConnected = await EthConversionProxyContract.connect(signer); - const adminNonce = await signer.getTransactionCount(); - const gasPrice = await provider.getGasPrice(); - - // start from the adminNonce, increase gasPrice if needed - await Promise.all([ - updatePaymentErc20FeeProxy(EthConversionProxyConnected, network, adminNonce, gasPrice), - updateChainlinkConversionPath( - EthConversionProxyConnected, - network, - adminNonce + 1, - gasPrice, - ), - ]); - }), - ); - console.log('Setup for EthConversionProxy successful'); -}; - -/** - * Updates the values of either BatchPayments, EthConversionProxy, or ERC20SwapToConversion contract, if needed + * Updates the values of either BatchPayments, ETHConversionProxy, or ERC20SwapToConversion contract, if needed * @param contractAddress address of the proxy * @param hre Hardhat runtime environment * @param contractName name of the contract @@ -148,8 +15,8 @@ export const setupContract = async ( contractName: string, ): Promise => { switch (contractName) { - case 'EthConversionProxy': { - await setupEthConversionProxy(contractAddress, hre); + case 'ETHConversionProxy': { + await setupETHConversionProxy(contractAddress, hre); break; } case 'ERC20SwapToConversion': { diff --git a/packages/smart-contracts/scripts-create2/deploy.ts~007d33cc... refactor: setups.ts b/packages/smart-contracts/scripts-create2/deploy.ts~007d33cc... refactor: setups.ts new file mode 100644 index 0000000000..ec15644fac --- /dev/null +++ b/packages/smart-contracts/scripts-create2/deploy.ts~007d33cc... refactor: setups.ts @@ -0,0 +1,87 @@ +import { create2ContractDeploymentList, isContractDeployed } from './utils'; +import { IDeploymentParams } from './types'; +import { HardhatRuntimeEnvironmentExtended } from './types'; +import { xdeploy } from './xdeployer'; +import { getConstructorArgs } from './constructor-args'; +import { setupERC20SwapToConversion } from './contract-setup'; +import { setupBatchPayments } from './contract-setup/setupBatchPayments'; + +// Deploys, set up the contracts and returns the address +export const deployOneWithCreate2 = async ( + deploymentParams: IDeploymentParams, + hre: HardhatRuntimeEnvironmentExtended, +): Promise => { + if (!hre.config.xdeploy.networks || hre.config.xdeploy.networks.length === 0) { + throw new Error('Invalid networks'); + } + // Deploy the contract on several network through xdeployer + const deploymentResult = await xdeploy(deploymentParams, hre); + for (let i = 0; i < hre.config.xdeploy.networks.length; i++) { + if (deploymentResult[i].deployed) { + console.log(`${deploymentParams.contract} successfully deployed:`); + console.log(` On network: ${hre.config.xdeploy.networks[i]}`); + console.log(` At address: ${deploymentResult[i].address}`); + console.log(` At block: ${deploymentResult[i].receipt.blockNumber}`); + } else { + if ( + isContractDeployed( + deploymentParams.contract, + hre.config.xdeploy.networks[i], + deploymentResult[i].address, + ) + ) { + console.log(`${deploymentParams.contract} already deployed:`); + console.log(` On network: ${hre.config.xdeploy.networks[i]}`); + console.log(` At address: ${deploymentResult[i].address}`); + } else { + console.log(`${deploymentParams.contract} has not been deployed:`); + console.log(` On network: ${hre.config.xdeploy.networks[i]}`); + console.log(` Error: ${deploymentResult[i].error}`); + console.log( + ` Hint: Check admin wallet balance and that your artifacts are up to date`, + ); + } + } + } + return deploymentResult[0].address; +}; + +export const deployWithCreate2FromList = async ( + hre: HardhatRuntimeEnvironmentExtended, +): Promise => { + for (const contract of create2ContractDeploymentList) { + switch (contract) { + case 'EthereumProxy': + case 'EthereumFeeProxy': + case 'ETHConversionProxy': + case 'ERC20FeeProxy': + case 'Erc20ConversionProxy': { + const constructorArgs = getConstructorArgs(contract); + await deployOneWithCreate2({ contract, constructorArgs }, hre); + break; + } + case 'ERC20SwapToConversion': { + const constructorArgs = getConstructorArgs(contract); + const address = await deployOneWithCreate2({ contract, constructorArgs }, hre); + await setupERC20SwapToConversion(address, hre); + break; + } + case 'ERC20EscrowToPay': { + const network = hre.config.xdeploy.networks[0]; + const constructorArgs = getConstructorArgs(contract, network); + await deployOneWithCreate2({ contract, constructorArgs }, hre); + break; + } + case 'BatchPayments': { + const network = hre.config.xdeploy.networks[0]; + const constructorArgs = getConstructorArgs(contract, network); + const address = await deployOneWithCreate2({ contract, constructorArgs }, hre); + await setupBatchPayments(address, hre); + break; + } + // Other cases to add when necessary + default: + throw new Error(`The contract ${contract} is not to be deployed using the CREATE2 scheme`); + } + } +}; diff --git a/packages/smart-contracts/scripts-create2/utils.ts b/packages/smart-contracts/scripts-create2/utils.ts index 421bba148c..d5be7e5c33 100644 --- a/packages/smart-contracts/scripts-create2/utils.ts +++ b/packages/smart-contracts/scripts-create2/utils.ts @@ -39,7 +39,7 @@ export const getArtifact = (contract: string): artifacts.ContractArtifact => { + try { + await hre.run('verify:verify', { + address: contractAddress, + constructorArguments: deploymentParams.constructorArgs, + }); + } catch (err) { + console.log(err); + } +}; + +export async function VerifyCreate2FromList(hre: HardhatRuntimeEnvironmentExtended): Promise { + try { + let address: string; + await Promise.all( + create2ContractDeploymentList.map(async (contract) => { + switch (contract) { + case 'EthereumProxy': + case 'EthereumFeeProxy': + case 'ETHConversionProxy': + case 'ERC20FeeProxy': + case 'ERC20SwapToConversion': + case 'Erc20ConversionProxy': { + const constructorArgs = getConstructorArgs(contract); + address = await computeCreate2DeploymentAddress({ contract, constructorArgs }, hre); + await verifyOne(address, { contract, constructorArgs }, hre); + break; + } + case 'ERC20EscrowToPay': { + const network = hre.config.xdeploy.networks[0]; + const constructorArgs = getConstructorArgs(contract, network); + address = await computeCreate2DeploymentAddress({ contract, constructorArgs }, hre); + await verifyOne(address, { contract, constructorArgs }, hre); + break; + } + case 'BatchPayments': { + const network = hre.config.xdeploy.networks[0]; + const constructorArgs = getConstructorArgs(contract, network); + address = await computeCreate2DeploymentAddress({ contract, constructorArgs }, hre); + await verifyOne(address, { contract, constructorArgs }, hre); + break; + } + // Other cases to add when necessary + default: + throw new Error( + `The contrat ${contract} is not to be deployed using the CREATE2 scheme`, + ); + } + }), + ); + } catch (e) { + console.error(e); + } +} diff --git a/packages/smart-contracts/scripts/conversion-proxy.ts b/packages/smart-contracts/scripts/conversion-proxy.ts index b0d96e8017..57fa687a24 100644 --- a/packages/smart-contracts/scripts/conversion-proxy.ts +++ b/packages/smart-contracts/scripts/conversion-proxy.ts @@ -45,7 +45,7 @@ export async function deployERC20ConversionProxy( }); } -export async function deployETHConversionProxy( +export async function deployEthConversionProxy( args: { chainlinkConversionPathAddress?: string; ethFeeProxyAddress?: string; diff --git a/packages/smart-contracts/scripts/deploy-payments.ts b/packages/smart-contracts/scripts/deploy-payments.ts index 14167c7c78..e9a868fdae 100644 --- a/packages/smart-contracts/scripts/deploy-payments.ts +++ b/packages/smart-contracts/scripts/deploy-payments.ts @@ -5,7 +5,7 @@ import { erc20FeeProxyArtifact, erc20SwapToPayArtifact, } from '../src/lib'; -import { deployERC20ConversionProxy, deployETHConversionProxy } from './conversion-proxy'; +import { deployERC20ConversionProxy, deployEthConversionProxy } from './conversion-proxy'; import { DeploymentResult, deployOne } from './deploy-one'; import { uniswapV2RouterAddresses, jumpToNonce } from './utils'; import { Contract } from 'ethers'; @@ -154,7 +154,7 @@ export async function deployAllPaymentContracts( /* * Batch 4 * - ChainlinkConversionPath (+ addWhitelistAdmin()) - * - ETHConversionProxy + * - EthConversionProxy */ const runDeploymentBatch_4 = async (ethFeeProxyAddress: string) => { const NONCE_BATCH_4 = 10; @@ -170,7 +170,7 @@ export async function deployAllPaymentContracts( }); // Deploy ETH Conversion - const ethConversionResult = await deployETHConversionProxy( + const ethConversionResult = await deployEthConversionProxy( { ...args, chainlinkConversionPathAddress, @@ -265,12 +265,12 @@ export async function deployAllPaymentContracts( const ethConversionAdminNonce = NONCE_BATCH_5 + 3; await jumpToNonce(args, hre, ethConversionAdminNonce); - // 5.d ETHConversion.transferOwnership + // 5.d EthConversion.transferOwnership if (await nonceReady(ethConversionAdminNonce)) { if (ethConversionResultInstance) { if (!process.env.ADMIN_WALLET_ADDRESS) { throw new Error( - 'ADMIN_WALLET_ADDRESS missing, cannot addWhitelistAdmin on ETHConversion.', + 'ADMIN_WALLET_ADDRESS missing, cannot addWhitelistAdmin on EthConversion.', ); } if (args.simulate === false) { @@ -280,13 +280,13 @@ export async function deployAllPaymentContracts( await tx.wait(1); } else { console.log( - `[i] Simulating addWhitelistAdmin to ETHConversion at ${ethConversionResultInstance.address}`, + `[i] Simulating addWhitelistAdmin to EthConversion at ${ethConversionResultInstance.address}`, ); } } else { if (!ethConversionResultInstance) { console.warn( - `Warning: the ETHConversion contract instance is not ready for ETHConversion update, consider retrying.`, + `Warning: the EthConversion contract instance is not ready for EthConversion update, consider retrying.`, ); switchToSimulation(); } diff --git a/packages/smart-contracts/scripts/test-deploy_chainlink_contract.ts b/packages/smart-contracts/scripts/test-deploy_chainlink_contract.ts index 88fa62a254..099be843a4 100644 --- a/packages/smart-contracts/scripts/test-deploy_chainlink_contract.ts +++ b/packages/smart-contracts/scripts/test-deploy_chainlink_contract.ts @@ -1,7 +1,7 @@ import '@nomiclabs/hardhat-ethers'; import { CurrencyManager } from '@requestnetwork/currency'; import { HardhatRuntimeEnvironment } from 'hardhat/types'; -import { deployERC20ConversionProxy, deployETHConversionProxy } from './conversion-proxy'; +import { deployERC20ConversionProxy, deployEthConversionProxy } from './conversion-proxy'; import { deploySwapConversion } from './erc20-swap-to-conversion'; import { deployOne } from './deploy-one'; @@ -93,7 +93,7 @@ export default async function deploy( // EthConversion const ethConversionProxyAddress = ( - await deployETHConversionProxy( + await deployEthConversionProxy( { ...args, chainlinkConversionPathAddress: conversionPathInstance.address, diff --git a/packages/smart-contracts/src/contracts/interfaces/IERC20ConversionProxy.sol b/packages/smart-contracts/src/contracts/interfaces/IERC20ConversionProxy.sol index 946d170691..3a7b8b8f6a 100644 --- a/packages/smart-contracts/src/contracts/interfaces/IERC20ConversionProxy.sol +++ b/packages/smart-contracts/src/contracts/interfaces/IERC20ConversionProxy.sol @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IERC20ConversionProxy { diff --git a/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts b/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts index ee0761fde6..817dd671ee 100644 --- a/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts +++ b/packages/smart-contracts/src/lib/artifacts/ChainlinkConversionPath/index.ts @@ -72,6 +72,10 @@ export const chainlinkConversionPath = new ContractArtifact( address: '0x4BA012eae4d64da79Bd6bcdBa366803fCe701A4C', creationBlockNumber: 18086337, }, + celo: { + address: '0xa015c141C02996EcE6410646DA3D07d70091c577', + creationBlockNumber: 13299808, + }, + xdai: { + address: '0xa015c141C02996EcE6410646DA3D07d70091c577', + creationBlockNumber: 22438806, + }, + 'arbitrum-one': { + address: '0xa015c141C02996EcE6410646DA3D07d70091c577', + creationBlockNumber: 13417262, + }, + fantom: { + address: '0xa015c141C02996EcE6410646DA3D07d70091c577', + creationBlockNumber: 39534777, + }, + bsc: { + address: '0xc7f471F5A8f8b33F131049b1e9A43941CbE31792', + creationBlockNumber: 18877277, + }, }, }, }, diff --git a/packages/smart-contracts/src/lib/artifacts/ERC20SwapToPay/index.ts b/packages/smart-contracts/src/lib/artifacts/ERC20SwapToPay/index.ts index ad9a3ff5eb..51c346834f 100644 --- a/packages/smart-contracts/src/lib/artifacts/ERC20SwapToPay/index.ts +++ b/packages/smart-contracts/src/lib/artifacts/ERC20SwapToPay/index.ts @@ -42,6 +42,10 @@ export const erc20SwapToPayArtifact = new ContractArtifact( address: '0x1B5077Ca852d39CDDeDaF45FAF1235841854420b', creationBlockNumber: 7408086, }, + goerli: { + address: '0x0Ef49176A87Adcc88bD5125126C6a6c23a28303C', + creationBlockNumber: 7109102, + }, bsc: { address: '0x75740D9b5cA3BCCb356CA7f0D0dB71aBE427a835', creationBlockNumber: 16165020, diff --git a/packages/smart-contracts/src/lib/artifacts/EthConversionProxy/index.ts b/packages/smart-contracts/src/lib/artifacts/EthConversionProxy/index.ts index 01ced6caa8..c9720fa6d9 100644 --- a/packages/smart-contracts/src/lib/artifacts/EthConversionProxy/index.ts +++ b/packages/smart-contracts/src/lib/artifacts/EthConversionProxy/index.ts @@ -55,6 +55,10 @@ export const ethConversionArtifact = new ContractArtifact( address: '0x7Ebf48a26253810629C191b56C3212Fd0D211c26', creationBlockNumber: 10023415, }, + goerli: { + address: '0xED250D9219EB93098Bb67aEbc992963172B9c8DA', + creationBlockNumber: 7108896, + }, fantom: { address: '0x7Ebf48a26253810629C191b56C3212Fd0D211c26', creationBlockNumber: 28552915, diff --git a/packages/smart-contracts/src/lib/artifacts/EthereumFeeProxy/index.ts b/packages/smart-contracts/src/lib/artifacts/EthereumFeeProxy/index.ts index 06dd436767..48bfbf6b22 100644 --- a/packages/smart-contracts/src/lib/artifacts/EthereumFeeProxy/index.ts +++ b/packages/smart-contracts/src/lib/artifacts/EthereumFeeProxy/index.ts @@ -66,6 +66,10 @@ export const ethereumFeeProxyArtifact = new ContractArtifact( address: '0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8', creationBlockNumber: 10307582, }, + goerli: { + address: '0xe11BF2fDA23bF0A98365e1A4c04A87C9339e8687', + creationBlockNumber: 7091386, + }, fantom: { address: '0xfCFBcfc4f5A421089e3Df45455F7f4985FE2D6a8', creationBlockNumber: 33495801, diff --git a/packages/smart-contracts/src/lib/artifacts/EthereumProxy/index.ts b/packages/smart-contracts/src/lib/artifacts/EthereumProxy/index.ts index 527cedbb78..b318578e54 100644 --- a/packages/smart-contracts/src/lib/artifacts/EthereumProxy/index.ts +++ b/packages/smart-contracts/src/lib/artifacts/EthereumProxy/index.ts @@ -21,10 +21,6 @@ export const ethereumProxyArtifact = new ContractArtifact( address: '0x9c6c7817e3679c4b3f9ef9486001eae5aaed25ff', creationBlockNumber: 5955681, }, - goerli: { - address: '0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e', - creationBlockNumber: 7069045, - }, xdai: { address: '0x27c60BE17e853c47A9F1d280B05365f483c2dFAF', creationBlockNumber: 18326895, @@ -136,6 +132,10 @@ export const ethereumProxyArtifact = new ContractArtifact( address: '0x322F0037d272E980984F89E94Aae43BD0FC065E6', creationBlockNumber: 10307566, }, + goerli: { + address: '0x171Ee0881407d4c0C11eA1a2FB7D5b4cdED71e6e', + creationBlockNumber: 7069045, + }, fantom: { address: '0x322F0037d272E980984F89E94Aae43BD0FC065E6', creationBlockNumber: 33496209,