Skip to content
This repository was archived by the owner on Jul 6, 2022. It is now read-only.

Commit 92119d7

Browse files
author
Victor Wiebe
committed
feat: adding getLockUP and getAllLockUpData. test issue
1 parent 1a12772 commit 92119d7

File tree

2 files changed

+223
-14
lines changed

2 files changed

+223
-14
lines changed

‎src/contract_wrappers/modules/transfer_manager/__tests__/lock_up_transfer_manager_wrapper.test.ts‎

Lines changed: 166 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,14 @@ import { getMockedPolyResponse, MockedCallMethod, MockedSendMethod } from '../..
1111
import LockUpTransferManagerWrapper from '../lock_up_transfer_manager_wrapper';
1212
import ContractFactory from '../../../../factories/contractFactory';
1313
import ModuleWrapper from '../../module_wrapper';
14-
import { dateToBigNumber, stringToBytes32, valueToWei, weiToValue } from '../../../../utils/convert';
15-
import { FULL_DECIMALS } from '../../../../types';
14+
import {
15+
bytes32ArrayToStringArray,
16+
dateToBigNumber,
17+
stringArrayToBytes32Array,
18+
stringToBytes32,
19+
valueToWei,
20+
weiToValue,
21+
} from '../../../../utils/convert';
1622

1723
describe('LockUpTransferManagerWrapper', () => {
1824
let target: LockUpTransferManagerWrapper;
@@ -196,10 +202,11 @@ describe('LockUpTransferManagerWrapper', () => {
196202
});
197203

198204
describe('lockups', () => {
199-
test.todo('should fail as lockup details is an empty string');
205+
test.todo('should fail as lockup name is an empty string');
200206

201207
test('should call to lockups', async () => {
202-
const expectedLockupAmount = valueToWei(new BigNumber(1), FULL_DECIMALS);
208+
const expectedDecimalsResult = new BigNumber(18);
209+
const expectedLockupAmount = valueToWei(new BigNumber(1), expectedDecimalsResult);
203210
const startTime = new Date(2030, 1);
204211
const expectedStartTime = dateToBigNumber(startTime);
205212
const expectedLockUpPeriodSeconds = new BigNumber(3600);
@@ -211,26 +218,177 @@ describe('LockUpTransferManagerWrapper', () => {
211218
expectedReleaseFrequencySeconds,
212219
];
213220
const mockedParams = {
214-
details: 'LockupDetails',
221+
lockupName: 'LockupDetails',
215222
};
223+
224+
// Security Token Address expected
225+
const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
226+
// Setup get Security Token Address
227+
const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
228+
when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
229+
when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
230+
when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
231+
instance(mockedSecurityTokenContract),
232+
);
233+
const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
234+
when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
235+
when(mockedSecurityTokenContract.decimals).thenReturn(instance(mockedSecurityTokenDecimalsMethod));
236+
216237
// Mocked method
217238
const mockedMethod = mock(MockedCallMethod);
218239
// Stub the method
219240
when(mockedContract.lockups).thenReturn(instance(mockedMethod));
220241
// Stub the request
221-
when(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.details)))).thenResolve(expectedResult);
242+
when(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.lockupName)))).thenResolve(
243+
expectedResult,
244+
);
222245

223246
// Real call
224247
const result = await target.lockups(mockedParams);
225248
// Result expectation
226-
expect(result.lockupAmount).toEqual(weiToValue(expectedLockupAmount, FULL_DECIMALS));
249+
expect(result.lockupAmount).toEqual(weiToValue(expectedLockupAmount, expectedDecimalsResult));
227250
expect(result.startTime).toEqual(startTime);
228251
expect(result.lockUpPeriodSeconds).toBe(expectedResult[2]);
229252
expect(result.releaseFrequencySeconds).toBe(expectedResult[3]);
230253

231254
// Verifications
232255
verify(mockedContract.lockups).once();
233-
verify(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.details)))).once();
256+
verify(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.lockupName)))).once();
257+
verify(mockedContract.securityToken).once();
258+
verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
259+
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
260+
verify(mockedSecurityTokenDecimalsMethod.callAsync()).once();
261+
verify(mockedSecurityTokenContract.decimals).once();
262+
});
263+
});
264+
265+
describe('getLockUp', () => {
266+
test.todo('should fail as lockup name is an empty string');
267+
268+
test('should call to getLockups', async () => {
269+
const expectedDecimalsResult = new BigNumber(18);
270+
const expectedLockupAmount = valueToWei(new BigNumber(2), expectedDecimalsResult);
271+
const startTime = new Date(2030, 1);
272+
const expectedStartTime = dateToBigNumber(startTime);
273+
const expectedLockUpPeriodSeconds = new BigNumber(3600);
274+
const expectedReleaseFrequencySeconds = new BigNumber(60);
275+
const expectedUnlockedAmount = new BigNumber(1);
276+
const expectedResult = [
277+
expectedLockupAmount,
278+
expectedStartTime,
279+
expectedLockUpPeriodSeconds,
280+
expectedReleaseFrequencySeconds,
281+
expectedUnlockedAmount,
282+
];
283+
const mockedParams = {
284+
lockupName: 'LockupDetails',
285+
};
286+
287+
// Security Token Address expected
288+
const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
289+
// Setup get Security Token Address
290+
const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
291+
when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
292+
when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
293+
when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
294+
instance(mockedSecurityTokenContract),
295+
);
296+
const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
297+
when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
298+
when(mockedSecurityTokenContract.decimals).thenReturn(instance(mockedSecurityTokenDecimalsMethod));
299+
300+
// Mocked method
301+
const mockedMethod = mock(MockedCallMethod);
302+
// Stub the method
303+
when(mockedContract.getLockUp).thenReturn(instance(mockedMethod));
304+
// Stub the request
305+
when(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.lockupName)))).thenResolve(
306+
expectedResult,
307+
);
308+
309+
// Real call
310+
const result = await target.getLockUp(mockedParams);
311+
// Result expectation
312+
expect(result.lockupAmount).toEqual(weiToValue(expectedLockupAmount, expectedDecimalsResult));
313+
expect(result.startTime).toEqual(startTime);
314+
expect(result.lockUpPeriodSeconds).toBe(expectedResult[2]);
315+
expect(result.releaseFrequencySeconds).toBe(expectedResult[3]);
316+
expect(result.unlockedAmount).toEqual(weiToValue(expectedUnlockedAmount, expectedDecimalsResult));
317+
318+
// Verifications
319+
verify(mockedContract.getLockUp).once();
320+
verify(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.lockupName)))).once();
321+
verify(mockedContract.securityToken).once();
322+
verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
323+
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
324+
verify(mockedSecurityTokenDecimalsMethod.callAsync()).once();
325+
verify(mockedSecurityTokenContract.decimals).once();
326+
});
327+
});
328+
329+
describe('getAllLockUpData', () => {
330+
test('should call to getAllLockupData', async () => {
331+
const expectedDecimalsResult = new BigNumber(18);
332+
const expectedNames = stringArrayToBytes32Array([
333+
'Lockup1',
334+
'Lockup2',
335+
]);
336+
const expectedLockupAmount = valueToWei(new BigNumber(2), expectedDecimalsResult);
337+
const startTime = new Date(2030, 1);
338+
const expectedStartTime = dateToBigNumber(startTime);
339+
const expectedLockUpPeriodSeconds = new BigNumber(3600);
340+
const expectedReleaseFrequencySeconds = new BigNumber(60);
341+
const expectedUnlockedAmount = new BigNumber(1);
342+
const expectedResult = [
343+
expectedNames,
344+
[expectedLockupAmount, expectedLockupAmount],
345+
[expectedStartTime, expectedStartTime],
346+
[expectedLockUpPeriodSeconds, expectedLockUpPeriodSeconds],
347+
[expectedReleaseFrequencySeconds, expectedReleaseFrequencySeconds],
348+
[expectedUnlockedAmount, expectedUnlockedAmount],
349+
];
350+
351+
// Security Token Address expected
352+
const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
353+
// Setup get Security Token Address
354+
const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
355+
when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
356+
when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
357+
when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
358+
instance(mockedSecurityTokenContract),
359+
);
360+
const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
361+
when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
362+
when(mockedSecurityTokenContract.decimals).thenReturn(instance(mockedSecurityTokenDecimalsMethod));
363+
364+
// Mocked method
365+
const mockedMethod = mock(MockedCallMethod);
366+
// Stub the method
367+
when(mockedContract.getAllLockupData).thenReturn(instance(mockedMethod));
368+
// Stub the request
369+
when(mockedMethod.callAsync()).thenResolve(expectedResult);
370+
371+
// Real call
372+
const result = await target.getAllLockupData();
373+
// Result expectation
374+
expect(result[0].lockupName).toEqual(expectedResult[0][0]);
375+
for(let i=0; i<result.length; i+=1) {
376+
expect(result[1].lockupName).toEqual(bytes32ArrayToStringArray(expectedNames));
377+
expect(result[i].lockupAmount).toEqual(weiToValue(expectedLockupAmount, expectedDecimalsResult));
378+
expect(result[i].startTime).toEqual(startTime);
379+
expect(result[i].lockUpPeriodSeconds).toBe(expectedResult[2]);
380+
expect(result[i].releaseFrequencySeconds).toBe(expectedResult[3]);
381+
expect(result[i].unlockedAmount).toEqual(weiToValue(expectedUnlockedAmount, expectedDecimalsResult));
382+
};
383+
384+
// Verifications
385+
verify(mockedContract.getAllLockupData).once();
386+
verify(mockedMethod.callAsync()).once();
387+
verify(mockedContract.securityToken).once();
388+
verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
389+
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
390+
verify(mockedSecurityTokenDecimalsMethod.callAsync()).once();
391+
verify(mockedSecurityTokenContract.decimals).once();
234392
});
235393
});
236394

‎src/contract_wrappers/modules/transfer_manager/lock_up_transfer_manager_wrapper.ts‎

Lines changed: 57 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -21,15 +21,21 @@ import ModuleWrapper from '../module_wrapper';
2121
import ContractFactory from '../../../factories/contractFactory';
2222
import {
2323
EventCallback,
24-
FULL_DECIMALS,
2524
GetLogs,
2625
GetLogsAsyncParams,
2726
Subscribe,
2827
SubscribeAsyncParams,
2928
TransferResult,
3029
TxParams,
3130
} from '../../../types';
32-
import { bigNumberToDate, parseTransferResult, stringToBytes32, valueToWei, weiToValue } from '../../../utils/convert';
31+
import {
32+
bigNumberToDate,
33+
bytes32ToString,
34+
parseTransferResult,
35+
stringToBytes32,
36+
valueToWei,
37+
weiToValue,
38+
} from '../../../utils/convert';
3339

3440
interface AddLockUpToUserSubscribeAsyncParams extends SubscribeAsyncParams {
3541
eventName: LockUpTransferManagerEvents.AddLockUpToUser;
@@ -125,7 +131,7 @@ interface GetLockUpTransferManagerLogsAsyncParams extends GetLogs {
125131
}
126132

127133
interface LockupsParams extends TxParams {
128-
details: string;
134+
lockupName: string;
129135
}
130136

131137
interface VerifyTransferParams {
@@ -143,6 +149,14 @@ interface LockUp {
143149
releaseFrequencySeconds: BigNumber;
144150
}
145151

152+
interface GetLockUp extends LockUp {
153+
unlockedAmount: BigNumber;
154+
}
155+
156+
interface GetLockupData extends GetLockUp {
157+
lockupName: string;
158+
}
159+
146160
interface VerifyTransfer {
147161
transferResult: TransferResult;
148162
address: string;
@@ -191,16 +205,53 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
191205
* Return the lockups
192206
*/
193207
public lockups = async (params: LockupsParams): Promise<LockUp> => {
194-
assert.assert(params.details.length > 0, 'LockUp Details must not be an empty string');
195-
const result = await (await this.contract).lockups.callAsync(stringToBytes32(params.details));
208+
assert.assert(params.lockupName.length > 0, 'LockUp Details must not be an empty string');
209+
const result = await (await this.contract).lockups.callAsync(stringToBytes32(params.lockupName));
210+
const decimals = await (await this.securityTokenContract()).decimals.callAsync();
196211
return {
197-
lockupAmount: weiToValue(result[0], FULL_DECIMALS),
212+
lockupAmount: weiToValue(result[0], decimals),
198213
startTime: bigNumberToDate(result[1]),
199214
lockUpPeriodSeconds: result[2],
200215
releaseFrequencySeconds: result[3],
201216
};
202217
};
203218

219+
/**
220+
* getLockups
221+
*/
222+
public getLockUp = async (params: LockupsParams): Promise<GetLockUp> => {
223+
assert.assert(params.lockupName.length > 0, 'LockUp Details must not be an empty string');
224+
const result = await (await this.contract).getLockUp.callAsync(stringToBytes32(params.lockupName));
225+
const decimals = await (await this.securityTokenContract()).decimals.callAsync();
226+
return {
227+
lockupAmount: weiToValue(result[0], decimals),
228+
startTime: bigNumberToDate(result[1]),
229+
lockUpPeriodSeconds: result[2],
230+
releaseFrequencySeconds: result[3],
231+
unlockedAmount: weiToValue(result[4], decimals),
232+
};
233+
};
234+
235+
/**
236+
* getAllLockupData
237+
*/
238+
public getAllLockupData = async (): Promise<GetLockupData[]> => {
239+
const result = await (await this.contract).getAllLockupData.callAsync();
240+
const decimals = await (await this.securityTokenContract()).decimals.callAsync();
241+
const typedResult: GetLockupData[] = [];
242+
for (let i = 0; i <= result[0].length; i += 1) {
243+
typedResult.push({
244+
lockupName: bytes32ToString(result[0][i]),
245+
lockupAmount: weiToValue(result[1][i], decimals),
246+
startTime: bigNumberToDate(result[2][i]),
247+
lockUpPeriodSeconds: result[3][i],
248+
releaseFrequencySeconds: result[4][i],
249+
unlockedAmount: weiToValue(result[1][i], decimals),
250+
});
251+
}
252+
return typedResult;
253+
};
254+
204255
public verifyTransfer = async (params: VerifyTransferParams): Promise<VerifyTransfer> => {
205256
assert.isETHAddressHex('from', params.from);
206257
assert.isETHAddressHex('to', params.to);

0 commit comments

Comments
 (0)