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

Commit e22e829

Browse files
shuffledexshuffledex
committed
fix: 🐛 manual merge in all getLogsAsync methods
2 parents 123d29c + 9ca7f0f commit e22e829

35 files changed

+3331
-369
lines changed

‎examples/lockUpTransferManager.ts‎

Lines changed: 231 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,231 @@
1+
import { RedundantSubprovider, RPCSubprovider, Web3ProviderEngine } from '@0x/subproviders';
2+
import { BigNumber, LockUpTransferManagerEvents } from '@polymathnetwork/abi-wrappers';
3+
import ModuleFactoryWrapper from '../src/contract_wrappers/modules/module_factory_wrapper';
4+
import { ApiConstructorParams, PolymathAPI } from '../src/PolymathAPI';
5+
import { ModuleName, ModuleType } from '../src';
6+
7+
// This file acts as a valid sandbox for using a lockup restriction transfer manager module on an unlocked node (like ganache)
8+
window.addEventListener('load', async () => {
9+
// Setup the redundant provider
10+
const providerEngine = new Web3ProviderEngine();
11+
providerEngine.addProvider(new RedundantSubprovider([new RPCSubprovider('http://127.0.0.1:8545')]));
12+
providerEngine.start();
13+
const params: ApiConstructorParams = {
14+
provider: providerEngine,
15+
polymathRegistryAddress: '<Deployed Polymath Registry address>',
16+
};
17+
18+
// Instantiate the API
19+
const polymathAPI = new PolymathAPI(params);
20+
21+
// Get some poly tokens in your account and the security token
22+
const myAddress = await polymathAPI.getAccount();
23+
await polymathAPI.getPolyTokens({ amount: new BigNumber(1000000), address: myAddress });
24+
25+
// Prompt to setup your ticker and token name
26+
const ticker = prompt('Ticker', '');
27+
const tokenName = prompt('Token Name', '');
28+
29+
// Double check available
30+
await polymathAPI.securityTokenRegistry.tickerAvailable({
31+
ticker: ticker!,
32+
});
33+
// Get the ticker fee and approve the security token registry to spend
34+
const tickerFee = await polymathAPI.securityTokenRegistry.getTickerRegistrationFee();
35+
await polymathAPI.polyToken.approve({
36+
spender: await polymathAPI.securityTokenRegistry.address(),
37+
value: tickerFee,
38+
});
39+
// Register a ticker
40+
await polymathAPI.securityTokenRegistry.registerTicker({
41+
ticker: ticker!,
42+
tokenName: tokenName!,
43+
});
44+
// Get the st launch fee and approve the security token registry to spend
45+
const securityTokenLaunchFee = await polymathAPI.securityTokenRegistry.getSecurityTokenLaunchFee();
46+
await polymathAPI.polyToken.approve({
47+
spender: await polymathAPI.securityTokenRegistry.address(),
48+
value: securityTokenLaunchFee,
49+
});
50+
51+
await polymathAPI.securityTokenRegistry.generateNewSecurityToken({
52+
name: tokenName!,
53+
ticker: ticker!,
54+
tokenDetails: 'details',
55+
divisible: true,
56+
treasuryWallet: myAddress,
57+
protocolVersion: '0',
58+
});
59+
60+
console.log('Security Token Generated');
61+
62+
const moduleName = ModuleName.LockUpTransferManager;
63+
64+
const modules = await polymathAPI.moduleRegistry.getModulesByType({
65+
moduleType: ModuleType.TransferManager,
66+
});
67+
68+
const instances: Promise<ModuleFactoryWrapper>[] = [];
69+
modules.map(address => {
70+
instances.push(polymathAPI.moduleFactory.getModuleFactory(address));
71+
});
72+
const resultInstances = await Promise.all(instances);
73+
74+
const names: Promise<string>[] = [];
75+
resultInstances.map(instanceFactory => {
76+
names.push(instanceFactory.name());
77+
});
78+
const resultNames = await Promise.all(names);
79+
80+
const index = resultNames.indexOf(moduleName);
81+
82+
// Create a Security Token Instance
83+
const tickerSecurityTokenInstance = await polymathAPI.tokenFactory.getSecurityTokenInstanceFromTicker(ticker!);
84+
85+
// Get General TM Address to whitelist transfers
86+
const generalTMAddress = (await tickerSecurityTokenInstance.getModulesByName({
87+
moduleName: ModuleName.GeneralTransferManager,
88+
}))[0];
89+
const generalTM = await polymathAPI.moduleFactory.getModuleInstance({
90+
name: ModuleName.GeneralTransferManager,
91+
address: generalTMAddress,
92+
});
93+
94+
await tickerSecurityTokenInstance.addModule({
95+
moduleName,
96+
address: modules[index],
97+
archived: false,
98+
});
99+
100+
const lockUpTMAddress = (await tickerSecurityTokenInstance.getModulesByName({
101+
moduleName: ModuleName.LockUpTransferManager,
102+
}))[0];
103+
104+
const lockUpTM = await polymathAPI.moduleFactory.getModuleInstance({
105+
name: ModuleName.LockUpTransferManager,
106+
address: lockUpTMAddress,
107+
});
108+
109+
const randomBeneficiary1 = '0x2222222222222222222222222222222222222222';
110+
const randomBeneficiary2 = '0x3333333333333333333333333333333333333333';
111+
const firstLockUpName = 'Lockup1';
112+
const secondLockUpName = 'Lockup2';
113+
const thirdLockUpName = 'Lockup3';
114+
115+
await generalTM.modifyKYCDataMulti({
116+
investors: [myAddress, randomBeneficiary1, randomBeneficiary2],
117+
canReceiveAfter: [new Date(), new Date(), new Date()],
118+
canSendAfter: [new Date(), new Date(), new Date()],
119+
expiryTime: [new Date(2035, 1), new Date(2035, 1), new Date(2035, 1)],
120+
});
121+
122+
await tickerSecurityTokenInstance.issueMulti({
123+
investors: [myAddress, randomBeneficiary1, randomBeneficiary2],
124+
values: [new BigNumber(100), new BigNumber(100), new BigNumber(100)],
125+
});
126+
127+
// Subscribe to event of addLockUpToUser
128+
await lockUpTM.subscribeAsync({
129+
eventName: LockUpTransferManagerEvents.AddLockUpToUser,
130+
indexFilterValues: {},
131+
callback: async (error, log) => {
132+
if (error) {
133+
console.log(error);
134+
} else {
135+
console.log('New Lock Up added to user', log);
136+
}
137+
},
138+
});
139+
140+
// Add new lock up to user multi, so we can test the lockup
141+
await lockUpTM.addNewLockUpToUserMulti({
142+
userAddresses: [myAddress, randomBeneficiary1, randomBeneficiary2],
143+
startTimes: [new Date(2030, 1, 1), new Date(2030, 1, 1), new Date(2030, 1, 1)],
144+
lockUpPeriodSeconds: [new BigNumber(5), new BigNumber(5), new BigNumber(5)],
145+
releaseFrequenciesSeconds: [new BigNumber(1), new BigNumber(1), new BigNumber(1)],
146+
lockupAmounts: [new BigNumber(100), new BigNumber(100), new BigNumber(100)],
147+
lockupNames: [firstLockUpName, secondLockUpName, thirdLockUpName],
148+
});
149+
150+
// Try out transfer above lockup, will fail
151+
try {
152+
await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(1) });
153+
} catch (e) {
154+
console.log('Transfer above lockup amount fails as expected');
155+
}
156+
157+
// Subscribe to event of modify lock up type
158+
await lockUpTM.subscribeAsync({
159+
eventName: LockUpTransferManagerEvents.ModifyLockUpType,
160+
indexFilterValues: {},
161+
callback: async (error, log) => {
162+
if (error) {
163+
console.log(error);
164+
} else {
165+
console.log('Modify Lock Up Type', log);
166+
}
167+
},
168+
});
169+
170+
const startTime = new Date(Date.now() + 10000);
171+
// Modify the lockup types so that we can test in real time
172+
await lockUpTM.modifyLockUpTypeMulti({
173+
startTimes: [startTime, startTime, startTime],
174+
lockUpPeriodSeconds: [new BigNumber(5), new BigNumber(5), new BigNumber(5)],
175+
releaseFrequenciesSeconds: [new BigNumber(1), new BigNumber(1), new BigNumber(1)],
176+
lockupAmounts: [new BigNumber(20), new BigNumber(10), new BigNumber(10)],
177+
lockupNames: [firstLockUpName, secondLockUpName, thirdLockUpName],
178+
});
179+
180+
// Subscribe to event of remove lockup from user
181+
await lockUpTM.subscribeAsync({
182+
eventName: LockUpTransferManagerEvents.RemoveLockUpFromUser,
183+
indexFilterValues: {},
184+
callback: async (error, log) => {
185+
if (error) {
186+
console.log(error);
187+
} else {
188+
console.log('Remove lockup from user', log);
189+
}
190+
},
191+
});
192+
// Example removing lockup from beneficiary 2 and removing lockup type
193+
await lockUpTM.removeLockUpFromUser({ userAddress: randomBeneficiary2, lockupName: thirdLockUpName });
194+
await lockUpTM.removeLockupType({ lockupName: thirdLockUpName });
195+
196+
// Try to transfer 50, it is below lockup and will pass
197+
await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(50) });
198+
console.log('50 tokens transferred to randomBeneficiary2');
199+
200+
// Try out transfer above lockup, will fail
201+
try {
202+
await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(31) });
203+
} catch (e) {
204+
console.log('Transfer above lockup amount fails as expected');
205+
}
206+
207+
const sleep = (milliseconds: number) => {
208+
console.log(`Sleeping ${milliseconds / 1000} seconds`);
209+
return new Promise(resolve => setTimeout(resolve, milliseconds));
210+
};
211+
await sleep(10000);
212+
213+
// Time has passed, try out same transfer 1 above lockup, will pass
214+
await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(31) });
215+
console.log('31 more tokens transferred to randomBeneficiary2');
216+
217+
// Try out transfer 10 above lockup, will fail
218+
try {
219+
await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(10) });
220+
} catch (e) {
221+
console.log('Transfer above lockup amount fails as expected');
222+
}
223+
224+
await sleep(10000);
225+
226+
// Transfer out the rest of tokens now that lockup is over
227+
await tickerSecurityTokenInstance.transfer({ to: randomBeneficiary2, value: new BigNumber(19) });
228+
console.log('19 more tokens transferred to randomBeneficiary2');
229+
230+
tickerSecurityTokenInstance.unsubscribeAll();
231+
});

‎package.json‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
{
22
"name": "@polymathnetwork/contract-wrappers",
3-
"version": "2.0.0-beta.25",
3+
"version": "2.0.0-beta.28",
44
"description": "Smart TS wrappers for Polymath smart contracts",
55
"keywords": [
66
"polymath",
@@ -84,7 +84,7 @@
8484
"@0x/subproviders": "^4.1.1",
8585
"@0x/types": "^2.4.0",
8686
"@0x/typescript-typings": "^4.2.3",
87-
"@polymathnetwork/abi-wrappers": "3.0.0-beta.6",
87+
"@polymathnetwork/abi-wrappers": "3.0.0-beta.8",
8888
"@types/semver": "^6.0.1",
8989
"ethereumjs-blockstream": "6.0.0",
9090
"ethereumjs-util": "^6.1.0",

‎src/PolymathAPI.ts‎

Lines changed: 42 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -4,26 +4,27 @@ import {
44
BigNumber,
55
providerUtils,
66
Provider,
7-
PolymathRegistry,
8-
ISecurityTokenRegistry,
9-
ISecurityToken,
10-
PolyToken,
11-
ModuleRegistry,
12-
CappedSTO,
13-
ModuleFactory,
14-
USDTieredSTO,
15-
FeatureRegistry,
16-
GeneralTransferManager,
17-
GeneralPermissionManager,
18-
ERC20DividendCheckpoint,
19-
ManualApprovalTransferManager,
20-
CountTransferManager,
21-
PercentageTransferManager,
22-
EtherDividendCheckpoint,
23-
VolumeRestrictionTransferManager,
24-
PolyTokenFaucet,
25-
Module,
26-
ERC20Detailed,
7+
FeatureRegistryContract,
8+
ModuleRegistryContract,
9+
PolymathRegistryContract,
10+
ISecurityTokenRegistryContract,
11+
ModuleFactoryContract,
12+
ModuleContract,
13+
ERC20DividendCheckpointContract,
14+
EtherDividendCheckpointContract,
15+
GeneralPermissionManagerContract,
16+
CappedSTOContract,
17+
USDTieredSTOContract,
18+
CountTransferManagerContract,
19+
GeneralTransferManagerContract,
20+
ManualApprovalTransferManagerContract,
21+
PercentageTransferManagerContract,
22+
LockUpTransferManagerContract,
23+
ERC20DetailedContract,
24+
PolyTokenContract,
25+
PolyTokenFaucetContract,
26+
ISecurityTokenContract,
27+
VolumeRestrictionTMContract,
2728
} from '@polymathnetwork/abi-wrappers';
2829
import PolymathRegistryWrapper from './contract_wrappers/registries/polymath_registry_wrapper';
2930
import SecurityTokenRegistryWrapper from './contract_wrappers/registries/security_token_registry_wrapper';
@@ -135,46 +136,33 @@ export class PolymathAPI {
135136

136137
const abiArray = [
137138
// Registries
138-
FeatureRegistry.abi,
139-
ModuleRegistry.abi,
140-
PolymathRegistry.abi,
141-
ISecurityTokenRegistry.abi.filter(
142-
a =>
143-
a.type !== 'event' &&
144-
a.name !== 'RegisterTicker' &&
145-
a.inputs ===
146-
[
147-
{ indexed: true, name: '_owner', type: 'address' },
148-
{ indexed: false, name: '_ticker', type: 'string' },
149-
{ indexed: false, name: '_name', type: 'string' },
150-
{ indexed: true, name: '_registrationDate', type: 'uint256' },
151-
{ indexed: true, name: '_expiryDate', type: 'uint256' },
152-
{ indexed: false, name: '_fromAdmin', type: 'bool' },
153-
{ indexed: false, name: '_registrationFee', type: 'uint256' },
154-
],
155-
),
139+
FeatureRegistryContract.ABI(),
140+
ModuleRegistryContract.ABI(),
141+
PolymathRegistryContract.ABI(),
142+
ISecurityTokenRegistryContract.ABI(),
156143
// Modules
157-
ModuleFactory.abi,
158-
Module.abi,
144+
ModuleFactoryContract.ABI(),
145+
ModuleContract.ABI(),
159146
// Checkpoint
160-
ERC20DividendCheckpoint.abi,
161-
EtherDividendCheckpoint.abi,
147+
ERC20DividendCheckpointContract.ABI(),
148+
EtherDividendCheckpointContract.ABI(),
162149
// Permission
163-
GeneralPermissionManager.abi,
150+
GeneralPermissionManagerContract.ABI(),
164151
// STO
165-
CappedSTO.abi,
166-
USDTieredSTO.abi,
152+
CappedSTOContract.ABI(),
153+
USDTieredSTOContract.ABI(),
167154
// Transfer
168-
CountTransferManager.abi,
169-
GeneralTransferManager.abi,
170-
ManualApprovalTransferManager.abi,
171-
PercentageTransferManager.abi,
172-
VolumeRestrictionTransferManager.abi,
155+
CountTransferManagerContract.ABI(),
156+
GeneralTransferManagerContract.ABI(),
157+
ManualApprovalTransferManagerContract.ABI(),
158+
PercentageTransferManagerContract.ABI(),
159+
LockUpTransferManagerContract.ABI(),
160+
VolumeRestrictionTMContract.ABI(),
173161
// Tokens
174-
ERC20Detailed.abi,
175-
PolyToken.abi,
176-
PolyTokenFaucet.abi,
177-
ISecurityToken.abi,
162+
ERC20DetailedContract.ABI(),
163+
PolyTokenContract.ABI(),
164+
PolyTokenFaucetContract.ABI(),
165+
ISecurityTokenContract.ABI(),
178166
];
179167

180168
abiArray.forEach((abi): void => {

0 commit comments

Comments
 (0)