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

Commit 3642428

Browse files
author
Victor Wiebe
committed
feat: 🎸 addNewLockUpTypeMulti method and tests, prettier
1 parent 16f540e commit 3642428

File tree

2 files changed

+198
-34
lines changed

2 files changed

+198
-34
lines changed

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

Lines changed: 141 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,12 @@ import ModuleWrapper from '../../module_wrapper';
1414
import {
1515
bytes32ArrayToStringArray,
1616
bytes32ToString,
17+
dateArrayToBigNumberArray,
1718
dateToBigNumber,
1819
parsePermBytes32Value,
1920
stringArrayToBytes32Array,
2021
stringToBytes32,
22+
valueArrayToWeiArray,
2123
valueToWei,
2224
weiToValue,
2325
} from '../../../../utils/convert';
@@ -592,11 +594,10 @@ describe('LockUpTransferManagerWrapper', () => {
592594
});
593595
});
594596

595-
596597
describe('addNewLockUpType', () => {
597598
test('should call addNewLockUpType', async () => {
598599
const expectedOwnerResult = '0x8888888888888888888888888888888888888888';
599-
const lockupName= 'Lockup1';
600+
const lockupName = 'Lockup1';
600601
const expectedDecimalsResult = new BigNumber(18);
601602
const expectedLockupAmount = valueToWei(new BigNumber(0), expectedDecimalsResult);
602603
const expectedStartTime = new BigNumber(0);
@@ -621,7 +622,7 @@ describe('LockUpTransferManagerWrapper', () => {
621622
when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
622623
when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
623624
when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
624-
instance(mockedSecurityTokenContract),
625+
instance(mockedSecurityTokenContract),
625626
);
626627
const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
627628
when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
@@ -638,15 +639,15 @@ describe('LockUpTransferManagerWrapper', () => {
638639
// Stub the method
639640
when(mockedContract.getLockUp).thenReturn(instance(mockedGetLockupMethod));
640641
// Stub the request
641-
when(mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(mockedGetLockupParams.lockupName)))).thenResolve(
642-
expectedGetLockupResult,
643-
);
642+
when(
643+
mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(mockedGetLockupParams.lockupName))),
644+
).thenResolve(expectedGetLockupResult);
644645

645646
const mockedParams = {
646647
lockupAmount: new BigNumber(100),
647648
startTime: new Date(2030, 1),
648649
lockUpPeriodSeconds: new BigNumber(3600),
649-
releaseFrequencySeconds: new BigNumber(60),
650+
releaseFrequenciesSeconds: new BigNumber(60),
650651
lockupName,
651652
txData: {},
652653
safetyFactor: 10,
@@ -658,15 +659,15 @@ describe('LockUpTransferManagerWrapper', () => {
658659
when(mockedContract.addNewLockUpType).thenReturn(instance(mockedMethod));
659660
// Stub the request
660661
when(
661-
mockedMethod.sendTransactionAsync(
662-
objectContaining(mockedParams.lockupAmount),
663-
objectContaining(dateToBigNumber(mockedParams.startTime)),
664-
objectContaining(mockedParams.lockUpPeriodSeconds),
665-
objectContaining(mockedParams.releaseFrequencySeconds),
666-
stringToBytes32(mockedParams.lockupName),
667-
mockedParams.txData,
668-
mockedParams.safetyFactor,
669-
),
662+
mockedMethod.sendTransactionAsync(
663+
objectContaining(valueToWei(mockedParams.lockupAmount, expectedDecimalsResult)),
664+
objectContaining(dateToBigNumber(mockedParams.startTime)),
665+
objectContaining(mockedParams.lockUpPeriodSeconds),
666+
objectContaining(mockedParams.releaseFrequenciesSeconds),
667+
objectContaining(stringToBytes32(mockedParams.lockupName)),
668+
mockedParams.txData,
669+
mockedParams.safetyFactor,
670+
),
670671
).thenResolve(expectedResult);
671672

672673
// Real call
@@ -677,24 +678,135 @@ describe('LockUpTransferManagerWrapper', () => {
677678
// Verifications
678679
verify(mockedContract.addNewLockUpType).once();
679680
verify(
680-
mockedMethod.sendTransactionAsync(
681-
objectContaining(mockedParams.lockupAmount),
682-
objectContaining(dateToBigNumber(mockedParams.startTime)),
683-
objectContaining(mockedParams.lockUpPeriodSeconds),
684-
objectContaining(mockedParams.releaseFrequencySeconds),
685-
stringToBytes32(mockedParams.lockupName),
686-
mockedParams.txData,
687-
mockedParams.safetyFactor,
688-
),
681+
mockedMethod.sendTransactionAsync(
682+
objectContaining(valueToWei(mockedParams.lockupAmount, expectedDecimalsResult)),
683+
objectContaining(dateToBigNumber(mockedParams.startTime)),
684+
objectContaining(mockedParams.lockUpPeriodSeconds),
685+
objectContaining(mockedParams.releaseFrequenciesSeconds),
686+
objectContaining(stringToBytes32(mockedParams.lockupName)),
687+
mockedParams.txData,
688+
mockedParams.safetyFactor,
689+
),
689690
).once();
690691
verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
691692
verify(mockedSecurityTokenContract.owner).once();
692-
verify(mockedContract.securityToken).twice();
693-
verify(mockedGetSecurityTokenAddressMethod.callAsync()).twice();
694-
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).twice();
693+
verify(mockedContract.securityToken).thrice();
694+
verify(mockedGetSecurityTokenAddressMethod.callAsync()).thrice();
695+
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thrice();
695696
verify(mockedWrapper.getAvailableAddressesAsync()).once();
696697
verify(mockedContract.getLockUp).once();
697-
verify(mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(mockedGetLockupParams.lockupName)))).once();
698+
verify(
699+
mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(mockedGetLockupParams.lockupName))),
700+
).once();
701+
});
702+
});
703+
704+
describe('addNewLockUpTypeMulti', () => {
705+
test('should call addNewLockUpTypeMulti', async () => {
706+
const expectedOwnerResult = '0x8888888888888888888888888888888888888888';
707+
const lockupNames = ['Lockup1', 'Lockup2'];
708+
const expectedDecimalsResult = new BigNumber(18);
709+
const expectedLockupAmount = valueToWei(new BigNumber(0), expectedDecimalsResult);
710+
const expectedStartTime = new BigNumber(0);
711+
const expectedLockUpPeriodSeconds = new BigNumber(0);
712+
const expectedReleaseFrequencySeconds = new BigNumber(0);
713+
const expectedUnlockedAmount = new BigNumber(0);
714+
const expectedGetLockupResult = [
715+
expectedLockupAmount,
716+
expectedStartTime,
717+
expectedLockUpPeriodSeconds,
718+
expectedReleaseFrequencySeconds,
719+
expectedUnlockedAmount,
720+
];
721+
const mockedGetLockupParams = {
722+
lockupNames,
723+
};
724+
725+
// Security Token Address expected
726+
const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
727+
// Setup get Security Token Address
728+
const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
729+
when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
730+
when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
731+
when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
732+
instance(mockedSecurityTokenContract),
733+
);
734+
const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
735+
when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
736+
when(mockedSecurityTokenContract.decimals).thenReturn(instance(mockedSecurityTokenDecimalsMethod));
737+
const mockedSecurityTokenOwnerMethod = mock(MockedCallMethod);
738+
when(mockedSecurityTokenOwnerMethod.callAsync()).thenResolve(expectedOwnerResult);
739+
when(mockedSecurityTokenContract.owner).thenReturn(instance(mockedSecurityTokenOwnerMethod));
740+
741+
// Mock web3 wrapper owner
742+
when(mockedWrapper.getAvailableAddressesAsync()).thenResolve([expectedOwnerResult]);
743+
744+
// Mocked method
745+
const mockedGetLockupMethod = mock(MockedCallMethod);
746+
// Stub the method
747+
when(mockedContract.getLockUp).thenReturn(instance(mockedGetLockupMethod));
748+
// Stub the request
749+
for(let i=0; i<lockupNames.length; i+=1) {
750+
when(mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(lockupNames[i])))).thenResolve(
751+
expectedGetLockupResult,
752+
);
753+
}
754+
755+
const mockedParams = {
756+
lockupAmounts: [new BigNumber(100), new BigNumber(200)],
757+
startTimes: [new Date(2030, 1), new Date(2030, 1)],
758+
lockUpPeriodSeconds: [new BigNumber(3600), new BigNumber(3600)],
759+
releaseFrequenciesSeconds: [new BigNumber(60), new BigNumber(60)],
760+
lockupNames,
761+
txData: {},
762+
safetyFactor: 10,
763+
};
764+
const expectedResult = getMockedPolyResponse();
765+
// Mocked method
766+
const mockedMethod = mock(MockedSendMethod);
767+
// Stub the method
768+
when(mockedContract.addNewLockUpTypeMulti).thenReturn(instance(mockedMethod));
769+
// Stub the request
770+
when(
771+
mockedMethod.sendTransactionAsync(
772+
objectContaining(valueArrayToWeiArray(mockedParams.lockupAmounts, expectedDecimalsResult)),
773+
objectContaining(dateArrayToBigNumberArray(mockedParams.startTimes)),
774+
objectContaining(mockedParams.lockUpPeriodSeconds),
775+
objectContaining(mockedParams.releaseFrequenciesSeconds),
776+
objectContaining(stringArrayToBytes32Array(mockedParams.lockupNames)),
777+
mockedParams.txData,
778+
mockedParams.safetyFactor,
779+
),
780+
).thenResolve(expectedResult);
781+
782+
// Real call
783+
const result = await target.addNewLockUpTypeMulti(mockedParams);
784+
785+
// Result expectation
786+
expect(result).toBe(expectedResult);
787+
// Verifications
788+
verify(mockedContract.addNewLockUpTypeMulti).once();
789+
verify(
790+
mockedMethod.sendTransactionAsync(
791+
objectContaining(valueArrayToWeiArray(mockedParams.lockupAmounts, expectedDecimalsResult)),
792+
objectContaining(dateArrayToBigNumberArray(mockedParams.startTimes)),
793+
objectContaining(mockedParams.lockUpPeriodSeconds),
794+
objectContaining(mockedParams.releaseFrequenciesSeconds),
795+
objectContaining(stringArrayToBytes32Array(mockedParams.lockupNames)),
796+
mockedParams.txData,
797+
mockedParams.safetyFactor,
798+
),
799+
).once();
800+
verify(mockedSecurityTokenOwnerMethod.callAsync()).once();
801+
verify(mockedSecurityTokenContract.owner).once();
802+
verify(mockedContract.securityToken).times(4);
803+
verify(mockedGetSecurityTokenAddressMethod.callAsync()).times(4);
804+
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).times(4);
805+
verify(mockedWrapper.getAvailableAddressesAsync()).once();
806+
verify(mockedContract.getLockUp).times(mockedGetLockupParams.lockupNames.length);
807+
for(let i=0; i<lockupNames.length; i+=1) {
808+
verify(mockedGetLockupMethod.callAsync(objectContaining(stringToBytes32(lockupNames[i])))).once();
809+
}
698810
});
699811
});
700812

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

Lines changed: 57 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -34,11 +34,13 @@ import {
3434
bigNumberToDate,
3535
bytes32ArrayToStringArray,
3636
bytes32ToString,
37+
dateArrayToBigNumberArray,
3738
dateToBigNumber,
38-
parseModuleTypeValue,
3939
parsePermBytes32Value,
4040
parseTransferResult,
41+
stringArrayToBytes32Array,
4142
stringToBytes32,
43+
valueArrayToWeiArray,
4244
valueToWei,
4345
weiToValue,
4446
} from '../../../utils/convert';
@@ -161,10 +163,18 @@ interface AddNewLockUpTypeParams extends TxParams {
161163
lockupAmount: BigNumber;
162164
startTime: Date;
163165
lockUpPeriodSeconds: BigNumber;
164-
releaseFrequencySeconds: BigNumber;
166+
releaseFrequenciesSeconds: BigNumber;
165167
lockupName: string;
166168
}
167169

170+
interface AddNewLockUpTypeMultiParams extends TxParams {
171+
lockupAmounts: BigNumber[];
172+
startTimes: Date[];
173+
lockUpPeriodSeconds: BigNumber[];
174+
releaseFrequenciesSeconds: BigNumber[];
175+
lockupNames: string[];
176+
}
177+
168178
// // Return types ////
169179
interface LockUp {
170180
lockupAmount: BigNumber;
@@ -358,17 +368,59 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
358368
public addNewLockUpType = async (params: AddNewLockUpTypeParams) => {
359369
assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
360370
await this.checkAddNewLockUpType(params);
371+
const decimals = await (await this.securityTokenContract()).decimals.callAsync();
361372
return (await this.contract).addNewLockUpType.sendTransactionAsync(
362-
params.lockupAmount,
373+
valueToWei(params.lockupAmount, decimals),
363374
dateToBigNumber(params.startTime),
364375
params.lockUpPeriodSeconds,
365-
params.releaseFrequencySeconds,
376+
params.releaseFrequenciesSeconds,
366377
stringToBytes32(params.lockupName),
367378
params.txData,
368379
params.safetyFactor,
369380
);
370381
};
371382

383+
/*
384+
* addNewLockUpTypeMulti
385+
*/
386+
public addNewLockUpTypeMulti = async (params: AddNewLockUpTypeMultiParams) => {
387+
assert.assert(params.lockupAmounts.length > 0, 'Empty lockup information');
388+
assert.areValidArrayLengths(
389+
[
390+
params.lockupAmounts,
391+
params.lockupNames,
392+
params.releaseFrequenciesSeconds,
393+
params.lockUpPeriodSeconds,
394+
params.startTimes,
395+
],
396+
'Argument arrays length mismatch',
397+
);
398+
assert.assert(await this.isCallerAllowed(params.txData, Perm.Admin), 'Caller is not allowed');
399+
const results = [];
400+
for (let i = 0; i < params.lockupNames.length; i += 1) {
401+
results.push(
402+
this.checkAddNewLockUpType({
403+
lockupAmount: params.lockupAmounts[i],
404+
startTime: params.startTimes[i],
405+
lockUpPeriodSeconds: params.lockUpPeriodSeconds[i],
406+
releaseFrequenciesSeconds: params.releaseFrequenciesSeconds[i],
407+
lockupName: params.lockupNames[i],
408+
}),
409+
);
410+
}
411+
await Promise.all(results);
412+
const decimals = await (await this.securityTokenContract()).decimals.callAsync();
413+
return (await this.contract).addNewLockUpTypeMulti.sendTransactionAsync(
414+
valueArrayToWeiArray(params.lockupAmounts, decimals),
415+
dateArrayToBigNumberArray(params.startTimes),
416+
params.lockUpPeriodSeconds,
417+
params.releaseFrequenciesSeconds,
418+
stringArrayToBytes32Array(params.lockupNames),
419+
params.txData,
420+
params.safetyFactor,
421+
);
422+
};
423+
372424
/**
373425
* Subscribe to an event type emitted by the contract.
374426
* @return Subscription token used later to unsubscribe
@@ -423,7 +475,7 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
423475
assert.isFutureDate(params.startTime, 'Start time must be in the future');
424476
assert.isBigNumberGreaterThanZero(params.lockUpPeriodSeconds, 'Lockup period in seconds should be greater than 0');
425477
assert.isBigNumberGreaterThanZero(
426-
params.releaseFrequencySeconds,
478+
params.releaseFrequenciesSeconds,
427479
'Release frequency in seconds should be greater than 0',
428480
);
429481
assert.isBigNumberGreaterThanZero(params.lockupAmount, 'Lockup amount should be greater than 0');

0 commit comments

Comments
 (0)