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

Commit 1a12772

Browse files
author
Victor Wiebe
committed
feat: add events, lockups and verifyTransfer to LTM
1 parent 2e441b6 commit 1a12772

File tree

2 files changed

+190
-23
lines changed

2 files changed

+190
-23
lines changed

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

Lines changed: 103 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,8 @@ 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 { valueToWei, weiToValue } from '../../../../utils/convert';
14+
import { dateToBigNumber, stringToBytes32, valueToWei, weiToValue } from '../../../../utils/convert';
15+
import { FULL_DECIMALS } from '../../../../types';
1516

1617
describe('LockUpTransferManagerWrapper', () => {
1718
let target: LockUpTransferManagerWrapper;
@@ -194,6 +195,107 @@ describe('LockUpTransferManagerWrapper', () => {
194195
});
195196
});
196197

198+
describe('lockups', () => {
199+
test.todo('should fail as lockup details is an empty string');
200+
201+
test('should call to lockups', async () => {
202+
const expectedLockupAmount = valueToWei(new BigNumber(1), FULL_DECIMALS);
203+
const startTime = new Date(2030, 1);
204+
const expectedStartTime = dateToBigNumber(startTime);
205+
const expectedLockUpPeriodSeconds = new BigNumber(3600);
206+
const expectedReleaseFrequencySeconds = new BigNumber(60);
207+
const expectedResult = [
208+
expectedLockupAmount,
209+
expectedStartTime,
210+
expectedLockUpPeriodSeconds,
211+
expectedReleaseFrequencySeconds,
212+
];
213+
const mockedParams = {
214+
details: 'LockupDetails',
215+
};
216+
// Mocked method
217+
const mockedMethod = mock(MockedCallMethod);
218+
// Stub the method
219+
when(mockedContract.lockups).thenReturn(instance(mockedMethod));
220+
// Stub the request
221+
when(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.details)))).thenResolve(expectedResult);
222+
223+
// Real call
224+
const result = await target.lockups(mockedParams);
225+
// Result expectation
226+
expect(result.lockupAmount).toEqual(weiToValue(expectedLockupAmount, FULL_DECIMALS));
227+
expect(result.startTime).toEqual(startTime);
228+
expect(result.lockUpPeriodSeconds).toBe(expectedResult[2]);
229+
expect(result.releaseFrequencySeconds).toBe(expectedResult[3]);
230+
231+
// Verifications
232+
verify(mockedContract.lockups).once();
233+
verify(mockedMethod.callAsync(objectContaining(stringToBytes32(mockedParams.details)))).once();
234+
});
235+
});
236+
237+
describe('verifyTransfer', () => {
238+
test('should verify Transfer', async () => {
239+
const statusCode = new BigNumber(2);
240+
const expectedResult = [statusCode, '0x1111111111111111111111111111111111111111'];
241+
// Security Token Address expected
242+
const expectedSecurityTokenAddress = '0x3333333333333333333333333333333333333333';
243+
// Setup get Security Token Address
244+
const mockedGetSecurityTokenAddressMethod = mock(MockedCallMethod);
245+
when(mockedContract.securityToken).thenReturn(instance(mockedGetSecurityTokenAddressMethod));
246+
when(mockedGetSecurityTokenAddressMethod.callAsync()).thenResolve(expectedSecurityTokenAddress);
247+
when(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).thenResolve(
248+
instance(mockedSecurityTokenContract),
249+
);
250+
const expectedDecimalsResult = new BigNumber(18);
251+
const mockedSecurityTokenDecimalsMethod = mock(MockedCallMethod);
252+
when(mockedSecurityTokenDecimalsMethod.callAsync()).thenResolve(expectedDecimalsResult);
253+
when(mockedSecurityTokenContract.decimals).thenReturn(instance(mockedSecurityTokenDecimalsMethod));
254+
255+
const mockedParams = {
256+
from: '0x1111111111111111111111111111111111111111',
257+
to: '0x2222222222222222222222222222222222222222',
258+
amount: new BigNumber(10),
259+
data: 'Data',
260+
};
261+
// Mocked method
262+
const mockedMethod = mock(MockedCallMethod);
263+
// Stub the method
264+
when(mockedContract.verifyTransfer).thenReturn(instance(mockedMethod));
265+
// Stub the request
266+
when(
267+
mockedMethod.callAsync(
268+
mockedParams.from,
269+
mockedParams.to,
270+
objectContaining(valueToWei(mockedParams.amount, expectedDecimalsResult)),
271+
mockedParams.data,
272+
),
273+
).thenResolve(expectedResult);
274+
275+
// Real call
276+
const result = await target.verifyTransfer(mockedParams);
277+
278+
// Result expectation
279+
expect(result.transferResult).toBe(statusCode.toNumber());
280+
expect(result.address).toBe(expectedResult[1]);
281+
// Verifications
282+
verify(mockedContract.verifyTransfer).once();
283+
verify(
284+
mockedMethod.callAsync(
285+
mockedParams.from,
286+
mockedParams.to,
287+
objectContaining(valueToWei(mockedParams.amount, expectedDecimalsResult)),
288+
mockedParams.data,
289+
),
290+
).once();
291+
verify(mockedContract.securityToken).once();
292+
verify(mockedGetSecurityTokenAddressMethod.callAsync()).once();
293+
verify(mockedContractFactory.getSecurityTokenContract(expectedSecurityTokenAddress)).once();
294+
verify(mockedSecurityTokenDecimalsMethod.callAsync()).once();
295+
verify(mockedSecurityTokenContract.decimals).once();
296+
});
297+
});
298+
197299
describe('SubscribeAsync', () => {
198300
test('should throw as eventName does not belong to LockUpTransferManager', async () => {
199301
// Mocked parameters

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

Lines changed: 87 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,35 +1,35 @@
11
import {
2+
BigNumber,
3+
ContractAbi,
4+
LockUpTransferManager,
5+
LockUpTransferManagerAddLockUpToUserEventArgs,
6+
LockUpTransferManagerAddNewLockUpTypeEventArgs,
27
LockUpTransferManagerContract,
38
LockUpTransferManagerEventArgs,
49
LockUpTransferManagerEvents,
5-
LockUpTransferManagerAddLockUpToUserEventArgs,
6-
LockUpTransferManagerRemoveLockUpFromUserEventArgs,
710
LockUpTransferManagerModifyLockUpTypeEventArgs,
8-
LockUpTransferManagerAddNewLockUpTypeEventArgs,
9-
LockUpTransferManagerRemoveLockUpTypeEventArgs,
1011
LockUpTransferManagerPauseEventArgs,
12+
LockUpTransferManagerRemoveLockUpFromUserEventArgs,
13+
LockUpTransferManagerRemoveLockUpTypeEventArgs,
1114
LockUpTransferManagerUnpauseEventArgs,
12-
LockUpTransferManager,
13-
Web3Wrapper,
14-
ContractAbi,
1515
LogWithDecodedArgs,
16-
BigNumber,
16+
Web3Wrapper,
1717
} from '@polymathnetwork/abi-wrappers';
1818
import { schemas } from '@0x/json-schemas';
1919
import assert from '../../../utils/assert';
2020
import ModuleWrapper from '../module_wrapper';
2121
import ContractFactory from '../../../factories/contractFactory';
2222
import {
23-
TxParams,
24-
GetLogsAsyncParams,
25-
SubscribeAsyncParams,
2623
EventCallback,
27-
Subscribe,
24+
FULL_DECIMALS,
2825
GetLogs,
29-
Perm,
26+
GetLogsAsyncParams,
27+
Subscribe,
28+
SubscribeAsyncParams,
3029
TransferResult,
30+
TxParams,
3131
} from '../../../types';
32-
import { valueToWei, weiToValue } from '../../../utils/convert';
32+
import { bigNumberToDate, parseTransferResult, stringToBytes32, valueToWei, weiToValue } from '../../../utils/convert';
3333

3434
interface AddLockUpToUserSubscribeAsyncParams extends SubscribeAsyncParams {
3535
eventName: LockUpTransferManagerEvents.AddLockUpToUser;
@@ -41,12 +41,12 @@ interface GetAddLockUpToUserLogsAsyncParams extends GetLogsAsyncParams {
4141
}
4242

4343
interface RemoveLockUpFromUserSubscribeAsyncParams extends SubscribeAsyncParams {
44-
eventName: LockUpTransferManagerEvents.RemoveLockUpFromUser;
45-
callback: EventCallback<LockUpTransferManagerRemoveLockUpFromUserEventArgs>;
44+
eventName: LockUpTransferManagerEvents.RemoveLockUpFromUser;
45+
callback: EventCallback<LockUpTransferManagerRemoveLockUpFromUserEventArgs>;
4646
}
4747

4848
interface GetRemoveLockUpFromUserLogsAsyncParams extends GetLogsAsyncParams {
49-
eventName: LockUpTransferManagerEvents.RemoveLockUpFromUser;
49+
eventName: LockUpTransferManagerEvents.RemoveLockUpFromUser;
5050
}
5151

5252
interface ModifyLockUpTypeSubscribeAsyncParams extends SubscribeAsyncParams {
@@ -105,15 +105,49 @@ interface LockUpTransferManagerSubscribeAsyncParams extends Subscribe {
105105
}
106106

107107
interface GetLockUpTransferManagerLogsAsyncParams extends GetLogs {
108-
(params: GetAddLockUpToUserLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerAddLockUpToUserEventArgs>[]>;
109-
(params: GetRemoveLockUpFromUserLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerRemoveLockUpFromUserEventArgs>[]>;
110-
(params: GetModifyLockUpTypeLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerModifyLockUpTypeEventArgs>[]>;
111-
(params: GetAddNewLockUpTypeLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerAddNewLockUpTypeEventArgs>[]>;
112-
(params: GetRemoveLockUpTypeLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerRemoveLockUpTypeEventArgs>[]>;
108+
(params: GetAddLockUpToUserLogsAsyncParams): Promise<
109+
LogWithDecodedArgs<LockUpTransferManagerAddLockUpToUserEventArgs>[]
110+
>;
111+
(params: GetRemoveLockUpFromUserLogsAsyncParams): Promise<
112+
LogWithDecodedArgs<LockUpTransferManagerRemoveLockUpFromUserEventArgs>[]
113+
>;
114+
(params: GetModifyLockUpTypeLogsAsyncParams): Promise<
115+
LogWithDecodedArgs<LockUpTransferManagerModifyLockUpTypeEventArgs>[]
116+
>;
117+
(params: GetAddNewLockUpTypeLogsAsyncParams): Promise<
118+
LogWithDecodedArgs<LockUpTransferManagerAddNewLockUpTypeEventArgs>[]
119+
>;
120+
(params: GetRemoveLockUpTypeLogsAsyncParams): Promise<
121+
LogWithDecodedArgs<LockUpTransferManagerRemoveLockUpTypeEventArgs>[]
122+
>;
113123
(params: GetPauseLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerPauseEventArgs>[]>;
114124
(params: GetUnpauseLogsAsyncParams): Promise<LogWithDecodedArgs<LockUpTransferManagerUnpauseEventArgs>[]>;
115125
}
116126

127+
interface LockupsParams extends TxParams {
128+
details: string;
129+
}
130+
131+
interface VerifyTransferParams {
132+
from: string;
133+
to: string;
134+
amount: BigNumber;
135+
data: string;
136+
}
137+
138+
// // Return types ////
139+
interface LockUp {
140+
lockupAmount: BigNumber;
141+
startTime: Date;
142+
lockUpPeriodSeconds: BigNumber;
143+
releaseFrequencySeconds: BigNumber;
144+
}
145+
146+
interface VerifyTransfer {
147+
transferResult: TransferResult;
148+
address: string;
149+
}
150+
117151
/**
118152
* This class includes the functionality related to interacting with the LockUp Transfer Manager contract.
119153
*/
@@ -153,6 +187,37 @@ export default class LockUpTransferManagerWrapper extends ModuleWrapper {
153187
return (await this.contract).pause.sendTransactionAsync(params.txData, params.safetyFactor);
154188
};
155189

190+
/**
191+
* Return the lockups
192+
*/
193+
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));
196+
return {
197+
lockupAmount: weiToValue(result[0], FULL_DECIMALS),
198+
startTime: bigNumberToDate(result[1]),
199+
lockUpPeriodSeconds: result[2],
200+
releaseFrequencySeconds: result[3],
201+
};
202+
};
203+
204+
public verifyTransfer = async (params: VerifyTransferParams): Promise<VerifyTransfer> => {
205+
assert.isETHAddressHex('from', params.from);
206+
assert.isETHAddressHex('to', params.to);
207+
const decimals = await (await this.securityTokenContract()).decimals.callAsync();
208+
const result = await (await this.contract).verifyTransfer.callAsync(
209+
params.from,
210+
params.to,
211+
valueToWei(params.amount, decimals),
212+
params.data,
213+
);
214+
const transferResult = parseTransferResult(result[0]);
215+
return {
216+
transferResult,
217+
address: result[1],
218+
};
219+
};
220+
156221
/**
157222
* Subscribe to an event type emitted by the contract.
158223
* @return Subscription token used later to unsubscribe

0 commit comments

Comments
 (0)