mirror of
https://github.com/zoo-labs/zoo.git
synced 2026-11-10 22:32:34 +00:00
244 lines
7.8 KiB
TypeScript
244 lines
7.8 KiB
TypeScript
import { requireDependencies, setupTestFactory } from './utils'
|
|
|
|
const { expect } = requireDependencies()
|
|
|
|
const setupTest = setupTestFactory(['Bridge', 'ZOO'])
|
|
|
|
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
|
|
|
|
interface TokenCustomizations {
|
|
kind?: number
|
|
id?: number
|
|
chainId?: string | number
|
|
tokenAddress?: string
|
|
enabled?: boolean
|
|
}
|
|
|
|
const getTokenDefaults = (token: any, i: number): TokenCustomizations => ({
|
|
kind: 0,
|
|
id: i,
|
|
chainId: 1337 + i,
|
|
tokenAddress: token.address,
|
|
enabled: true,
|
|
})
|
|
|
|
const generateTokens = (token: any, count: number = 2, custom: TokenCustomizations = {}) => {
|
|
// Lame version
|
|
let tokens = []
|
|
for (let i = 0; i < count; i++) {
|
|
custom = { ...getTokenDefaults(token, i), ...custom }
|
|
tokens.push({
|
|
kind: custom.kind,
|
|
id: custom.id,
|
|
chainId: custom.chainId,
|
|
tokenAddress: custom.tokenAddress,
|
|
enabled: custom.enabled,
|
|
})
|
|
}
|
|
return tokens
|
|
}
|
|
|
|
describe('Bridge', function () {
|
|
describe('setToken', async () => {
|
|
it('allows owner to set token', async () => {
|
|
const {
|
|
tokens: { Bridge, ZOO },
|
|
} = await setupTest()
|
|
const [tokenA] = generateTokens(ZOO, 1)
|
|
ZOO.configure(Bridge.address)
|
|
await expect(Bridge.setToken(tokenA)).to.not.be.rejected
|
|
})
|
|
it('forbids setting Chain ID to address 0', async () => {
|
|
const {
|
|
tokens: { Bridge, ZOO },
|
|
} = await setupTest()
|
|
const [tokenA] = generateTokens(ZOO, 1, { chainId: ZERO_ADDRESS })
|
|
ZOO.configure(Bridge.address)
|
|
await expect(Bridge.setToken(tokenA)).to.be.rejectedWith('Chain ID must not be zero')
|
|
})
|
|
it('forbids setting token address to address 0', async () => {
|
|
const {
|
|
tokens: { Bridge, ZOO },
|
|
} = await setupTest()
|
|
const [tokenA] = generateTokens(ZOO, 1, { tokenAddress: ZERO_ADDRESS })
|
|
ZOO.configure(Bridge.address)
|
|
await expect(Bridge.setToken(tokenA)).to.be.rejectedWith('Token address must not be zero')
|
|
})
|
|
it('forbids any non-owner permission', async () => {
|
|
const {
|
|
signers,
|
|
tokens: { Bridge, ZOO },
|
|
} = await setupTest()
|
|
const [_user1, user2] = signers
|
|
const [tokenA] = generateTokens(ZOO, 1)
|
|
ZOO.configure(Bridge.address)
|
|
const bridge = Bridge.connect(user2)
|
|
|
|
await expect(bridge.setToken(tokenA)).to.be.rejectedWith('Ownable: caller is not the owner')
|
|
})
|
|
})
|
|
describe('swap', async () => {
|
|
let bridge: any
|
|
let token: any
|
|
let signers: any[]
|
|
let execGoodSwap: () => Promise<any>
|
|
let execBurnSwap: () => Promise<any>
|
|
|
|
beforeEach(async () => {
|
|
const {
|
|
signers: s,
|
|
owner,
|
|
tokens: { Bridge, ZOO },
|
|
} = await setupTest()
|
|
signers = s
|
|
bridge = Bridge
|
|
token = ZOO
|
|
token.configure(bridge.address)
|
|
await token.mint(s[0].address, 1000)
|
|
|
|
execGoodSwap = async () => {
|
|
const [user1] = signers
|
|
const [tokenA, tokenB] = generateTokens(token, 2, {})
|
|
|
|
await bridge.setToken(tokenA)
|
|
await bridge.setToken(tokenB)
|
|
await token.approve(bridge.address, 200)
|
|
|
|
const txn = await bridge.swap(tokenA, tokenB, user1.address, 100, 1)
|
|
const tx = await txn.wait()
|
|
return tx
|
|
}
|
|
execBurnSwap = async () => {
|
|
const [user1] = signers
|
|
const [tokenA] = generateTokens(token, 1, { chainId: 1338 })
|
|
const [tokenB] = generateTokens(token, 1, {})
|
|
|
|
await bridge.setToken(tokenA)
|
|
await bridge.setToken(tokenB)
|
|
await token.approve(bridge.address, 200)
|
|
|
|
const txn = await bridge.swap(tokenA, tokenB, user1.address, 100, 1)
|
|
const tx = await txn.wait()
|
|
return tx
|
|
}
|
|
})
|
|
|
|
// bridge.mint(token, s[0].address, 1000);
|
|
it('cannot swap tokens on a different chainId', async () => {
|
|
const [user1] = signers
|
|
const [tokenA, tokenB] = generateTokens(token, 2, { chainId: 1338 })
|
|
bridge.setToken(tokenA)
|
|
bridge.setToken(tokenB)
|
|
|
|
await token.approve(bridge.address, 200)
|
|
await expect(bridge.swap(tokenA, tokenB, user1.address, 100, 1)).to.be.rejectedWith('Wrong chain')
|
|
})
|
|
|
|
it('cannot swap a disabled token', async () => {
|
|
const [user1, user2, user3] = signers
|
|
const [tokenA] = generateTokens(token, 1, { enabled: false, tokenAddress: user2.address })
|
|
const [tokenB] = generateTokens(token, 1, { enabled: true, tokenAddress: user3.address })
|
|
await bridge.setToken(tokenA)
|
|
await bridge.setToken(tokenB)
|
|
|
|
await token.approve(bridge.address, 200)
|
|
|
|
await expect(bridge.swap(tokenA, tokenB, user1.address, 100, 1)).to.be.rejectedWith('Swap from token not enabled')
|
|
})
|
|
|
|
it('cannot swap to a disabled token', async () => {
|
|
const [user1, user2, user3] = signers
|
|
const [tokenA] = generateTokens(token, 1, { enabled: true, tokenAddress: user2.address })
|
|
const [tokenB] = generateTokens(token, 1, { enabled: false, tokenAddress: user3.address })
|
|
await bridge.setToken(tokenA)
|
|
await bridge.setToken(tokenB)
|
|
|
|
await token.approve(bridge.address, 200)
|
|
|
|
await expect(bridge.swap(tokenA, tokenB, user1.address, 100, 1)).to.be.rejectedWith('Swap to token not enabled')
|
|
})
|
|
|
|
it('can only swap a greater than zero amount', async () => {
|
|
const [user1] = signers
|
|
await token.approve(bridge.address, 200)
|
|
const [tokenA, tokenB] = generateTokens(token, 2, {})
|
|
|
|
bridge.setToken(tokenA)
|
|
bridge.setToken(tokenB)
|
|
|
|
await expect(bridge.swap(tokenA, tokenB, user1.address, 0, 2)).to.be.rejectedWith('Amount must be greater than zero')
|
|
})
|
|
|
|
it('can only to a non-zero account', async () => {
|
|
const [user1] = signers
|
|
const [tokenA, tokenB] = generateTokens(token, 2, {})
|
|
bridge.setToken(tokenA)
|
|
bridge.setToken(tokenB)
|
|
await token.approve(bridge.address, 200)
|
|
|
|
await expect(bridge.swap(tokenA, tokenB, user1.address, 0, 1)).to.be.rejectedWith('Amount must be greater than zero')
|
|
})
|
|
|
|
it('enforces nonce as a 1-time use', async () => {
|
|
const [user1] = signers
|
|
const [tokenA, tokenB] = generateTokens(token, 2, {})
|
|
bridge.setToken(tokenA)
|
|
bridge.setToken(tokenB)
|
|
await token.approve(bridge.address, 200)
|
|
|
|
await bridge.swap(tokenA, tokenB, user1.address, 100, 1)
|
|
await expect(bridge.swap(tokenA, tokenB, user1.address, 100, 1)).to.be.rejectedWith('Nonce already used')
|
|
})
|
|
|
|
it('it should swap tokens', async function () {
|
|
const { signers, tokens } = await setupTest()
|
|
|
|
const bridge = tokens.Bridge
|
|
const token = tokens.ZOO
|
|
token.configure(bridge.address)
|
|
|
|
const [user1, user2] = signers
|
|
const address1 = user1.address
|
|
const address2 = user2.address
|
|
|
|
// Mint tokens to user1
|
|
token.mint(address1, 10000)
|
|
await token.approve(bridge.address, 200)
|
|
|
|
const [tokenA, tokenB] = generateTokens(token, 2)
|
|
await bridge.setToken(tokenA)
|
|
await bridge.setToken(tokenB)
|
|
|
|
await expect(bridge.swap(tokenA, tokenB, address2, 100, 1)).to.not.be.rejected
|
|
})
|
|
|
|
it('throws a swap event with a successful swap', async () => {
|
|
const tx = await execGoodSwap()
|
|
|
|
expect(tx).not.to.be.null
|
|
expect(tx.events).not.to.be.null
|
|
expect(tx.events[0].event).to.be.eql('Swap')
|
|
})
|
|
|
|
it('throws a burn event if the from token is on the current chain', async () => {
|
|
const tx = await execGoodSwap()
|
|
|
|
expect(tx).not.to.be.null
|
|
expect(tx.events).not.to.be.null
|
|
expect(tx.events[tx.events.length - 1].event).to.be.eql('Burn')
|
|
})
|
|
|
|
it('not yet', async () => {
|
|
const tx = await execBurnSwap()
|
|
|
|
expect(tx.events[tx.events.length - 1].event).to.be.eql('Mint')
|
|
})
|
|
|
|
it('throws a mint event if the from token is on a different chain', async () => {
|
|
const tx = await execBurnSwap()
|
|
|
|
expect(tx.events[tx.events.length - 1].event).to.be.eql('Mint')
|
|
})
|
|
})
|
|
})
|