git.delta.rocks / unique-network / refs/commits / 383d45a29a75

30    fi30    fi
3131
32    echo -e "${GREEN}Baedeker env updated${RESET}"32    echo -e "${GREEN}Baedeker env updated${RESET}"
33    nginx_id=$(docker compose -f .baedeker/.bdk-env/docker-compose.yml ps --format=json | jq -r '.[] | select(.Service == "nginx") | .ID' -e)33    nginx_id=$(docker compose -f .baedeker/.bdk-env/docker-compose.yml ps --format=json | jq -s 'flatten' | jq -r '.[] | select(.Service == "nginx") | .ID' -e)
34    if ! [ $? -eq 0 ]; then34    if ! [ $? -eq 0 ]; then
35        echo -e "${RED}Nginx container not found${RESET}"35        echo -e "${RED}Nginx container not found${RESET}"
36        exit 036        exit 0

223  minimalBalance?: bigint,223  minimalBalance?: bigint,
224}224}
225
226export interface MoonbeamAssetInfo {
227  location: any,
228  metadata: {
229    name: string,
230    symbol: string,
231    decimals: number,
232    isFrozen: boolean,
233    minimalBalance: bigint,
234  },
235  existentialDeposit: bigint,
236  isSufficient: boolean,
237  unitsPerSecond: bigint,
238  numAssetsWeightHint: number,
239}
240
241export interface AcalaAssetMetadata {
242  name: string,
243  symbol: string,
244  decimals: number,
245  minimalBalance: bigint,
246}
247
248export interface DemocracyStandardAccountVote {
249  balance: bigint,
250  vote: {
251    aye: boolean,
252    conviction: number,
253  },
254}
255225
256export interface DemocracySplitAccount {226export interface DemocracySplitAccount {
257  aye: bigint,227  aye: bigint,

33
4import {stringToU8a} from '@polkadot/util';4import {stringToU8a} from '@polkadot/util';
5import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';5import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
6import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper, PolkadexHelper} from './unique';6import {UniqueHelper, ChainHelperBase, ChainHelperBaseConstructor} from './unique';
7import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';7import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';
8import * as defs from '../../interfaces/definitions';8import * as defs from '../../interfaces/definitions';
9import {IKeyringPair} from '@polkadot/types/types';9import {IKeyringPair} from '@polkadot/types/types';
10import {EventRecord} from '@polkadot/types/interfaces';10import {EventRecord} from '@polkadot/types/interfaces';
11import {ICrossAccountId, IPovInfo, ITransactionResult, TSigner} from './types';11import {ICrossAccountId, IPovInfo, ITransactionResult, TSigner} from './types';
12import {FrameSystemEventRecord, XcmV2TraitsError} from '@polkadot/types/lookup';12import {FrameSystemEventRecord, XcmV2TraitsError} from '@polkadot/types/lookup';
13import {VoidFn} from '@polkadot/api/types';13import {SignerOptions, VoidFn} from '@polkadot/api/types';
14import {Pallets} from '..';14import {Pallets} from '..';
15import {spawnSync} from 'child_process';15import {spawnSync} from 'child_process';
16import {AcalaHelper, AstarHelper, MoonbeamHelper, PolkadexHelper, RelayHelper, WestmintHelper} from './unique.xcm';
1617
17export class SilentLogger {18export class SilentLogger {
18  log(_msg: any, _level: any): void { }19  log(_msg: any, _level: any): void { }
260  };261  };
261}262}
263
264// eslint-disable-next-line @typescript-eslint/naming-convention
265export function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {
266  return class extends Base {
267    constructor(...args: any[]) {
268      super(...args);
269    }
270
271    async executeExtrinsic(
272      sender: IKeyringPair,
273      extrinsic: string,
274      params: any[],
275      expectSuccess?: boolean,
276      options: Partial<SignerOptions> | null = null,
277    ): Promise<ITransactionResult> {
278      const call = this.constructApiCall(extrinsic, params);
279      const result = await super.executeExtrinsic(
280        sender,
281        'api.tx.sudo.sudo',
282        [call],
283        expectSuccess,
284        options,
285      );
286
287      if(result.status === 'Fail') return result;
288
289      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;
290      if(data.isErr) {
291        if(data.asErr.isModule) {
292          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;
293          const metaError = super.getApi()?.registry.findMetaError(error);
294          throw new Error(`${metaError.section}.${metaError.name}`);
295        } else if(data.asErr.isToken) {
296          throw new Error(`Token: ${data.asErr.asToken}`);
297        }
298        // May be [object Object] in case of unhandled non-unit enum
299        throw new Error(`Misc: ${data.asErr.toHuman()}`);
300      }
301      return result;
302    }
303    async executeExtrinsicUncheckedWeight(
304      sender: IKeyringPair,
305      extrinsic: string,
306      params: any[],
307      expectSuccess?: boolean,
308      options: Partial<SignerOptions> | null = null,
309    ): Promise<ITransactionResult> {
310      const call = this.constructApiCall(extrinsic, params);
311      const result = await super.executeExtrinsic(
312        sender,
313        'api.tx.sudo.sudoUncheckedWeight',
314        [call, {refTime: 0, proofSize: 0}],
315        expectSuccess,
316        options,
317      );
318
319      if(result.status === 'Fail') return result;
320
321      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;
322      if(data.isErr) {
323        if(data.asErr.isModule) {
324          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;
325          const metaError = super.getApi()?.registry.findMetaError(error);
326          throw new Error(`${metaError.section}.${metaError.name}`);
327        } else if(data.asErr.isToken) {
328          throw new Error(`Token: ${data.asErr.asToken}`);
329        }
330        // May be [object Object] in case of unhandled non-unit enum
331        throw new Error(`Misc: ${data.asErr.toHuman()}`);
332      }
333      return result;
334    }
335  };
336}
262337
263export class DevUniqueHelper extends UniqueHelper {338export class DevUniqueHelper extends UniqueHelper {
264  /**339  /**
326    this.network = await UniqueHelper.detectNetwork(this.api);401    this.network = await UniqueHelper.detectNetwork(this.api);
327    this.wsEndpoint = wsEndpoint;402    this.wsEndpoint = wsEndpoint;
328  }403  }
404  getSudo<T extends UniqueHelper>() {
405    // eslint-disable-next-line @typescript-eslint/naming-convention
406    const SudoHelperType = SudoHelper(this.helperBase);
407    return this.clone(SudoHelperType) as T;
408  }
329}409}
330410
331export class DevRelayHelper extends RelayHelper {411export class DevRelayHelper extends RelayHelper {
387    this.wait = new WaitGroup(this);467    this.wait = new WaitGroup(this);
388  }468  }
469
470  getSudo<T extends UniqueHelper>() {
471    // eslint-disable-next-line @typescript-eslint/naming-convention
472    const SudoHelperType = SudoHelper(this.helperBase);
473    return this.clone(SudoHelperType) as T;
474  }
389}475}
390476
391export class DevShidenHelper extends AstarHelper {477export class DevShidenHelper extends AstarHelper {
408    super(logger, options);494    super(logger, options);
409    this.wait = new WaitGroup(this);495    this.wait = new WaitGroup(this);
410  }496  }
497  getSudo<T extends UniqueHelper>() {
498    // eslint-disable-next-line @typescript-eslint/naming-convention
499    const SudoHelperType = SudoHelper(this.helperBase);
500    return this.clone(SudoHelperType) as T;
501  }
411}502}
412503
413export class DevPolkadexHelper extends PolkadexHelper {504export class DevPolkadexHelper extends PolkadexHelper {
419    this.wait = new WaitGroup(this);510    this.wait = new WaitGroup(this);
420  }511  }
512
513  getSudo<T extends PolkadexHelper>() {
514    // eslint-disable-next-line @typescript-eslint/naming-convention
515    const SudoHelperType = SudoHelper(this.helperBase);
516    return this.clone(SudoHelperType) as T;
517  }
421}518}
422519
423export class DevKaruraHelper extends DevAcalaHelper {}520export class DevKaruraHelper extends DevAcalaHelper {}

40  TSubstrateAccount,40  TSubstrateAccount,
41  TNetworks,41  TNetworks,
42  IForeignAssetMetadata,42  IForeignAssetMetadata,
43  AcalaAssetMetadata,
44  MoonbeamAssetInfo,
45  DemocracyStandardAccountVote,
46  IEthCrossAccountId,43  IEthCrossAccountId,
47  IPhasicEvent,44  IPhasicEvent,
48} from './types';45} from './types';
818}815}
819816
820817
821class HelperGroup<T extends ChainHelperBase> {818export class HelperGroup<T extends ChainHelperBase> {
822  helper: T;819  helper: T;
823820
824  constructor(uniqueHelper: T) {821  constructor(uniqueHelper: T) {
2373  }2370  }
2374}2371}
23752372
2376class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2373export class SubstrateBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {
2377  /**2374  /**
2378 * Get substrate address balance2375 * Get substrate address balance
2379 * @param address substrate address2376 * @param address substrate address
2440  }2437  }
2441}2438}
24422439
2443class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {2440export class EthereumBalanceGroup<T extends ChainHelperBase> extends HelperGroup<T> {
2444  /**2441  /**
2445   * Get ethereum address balance2442   * Get ethereum address balance
2446   * @param address ethereum address2443   * @param address ethereum address
3595  }3592  }
3596}3593}
35973594
3598class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {3595export class XcmGroup<T extends ChainHelperBase> extends HelperGroup<T> {
3599  palletName: string;3596  palletName: string;
36003597
3601  constructor(helper: T, palletName: string) {3598  constructor(helper: T, palletName: string) {
3688  }3685  }
3689}3686}
36903687
3691class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3688export class XTokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {
3692  async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {3689  async transfer(signer: TSigner, currencyId: any, amount: bigint, destination: any, destWeight: any) {
3693    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);3690    await this.helper.executeExtrinsic(signer, 'api.tx.xTokens.transfer', [currencyId, amount, destination, destWeight], true);
3694  }3691  }
3702  }3699  }
3703}3700}
37043701
3705class PolkadexXcmHelperGroup<T extends ChainHelperBase> extends HelperGroup<T> {3702
3706  async whitelistToken(signer: TSigner, assetId: any) {
3707    await this.helper.executeExtrinsic(signer, 'api.tx.xcmHelper.whitelistToken', [assetId], true);
3708  }
3709}
37103703
3711class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {3704export class TokensGroup<T extends ChainHelperBase> extends HelperGroup<T> {
3712  async accounts(address: string, currencyId: any) {3705  async accounts(address: string, currencyId: any) {
3713    const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;3706    const {free} = (await this.helper.callRpc('api.query.tokens.accounts', [address, currencyId])).toJSON() as any;
3714    return BigInt(free);3707    return BigInt(free);
3715  }3708  }
3716}3709}
37173710
3718class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {3711export class AssetsGroup<T extends ChainHelperBase> extends HelperGroup<T> {
3719  async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {3712  async create(signer: TSigner, assetId: number, admin: string, minimalBalance: bigint) {
3720    await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);3713    await this.helper.executeExtrinsic(signer, 'api.tx.assets.create', [assetId, admin, minimalBalance], true);
3721  }3714  }
3755  }3748  }
3756}3749}
37573750
3758class AcalaAssetRegistryGroup extends HelperGroup<AcalaHelper> {3751
3759  async registerForeignAsset(signer: TSigner, destination: any, metadata: AcalaAssetMetadata) {
3760    await this.helper.executeExtrinsic(signer, 'api.tx.assetRegistry.registerForeignAsset', [destination, metadata], true);
3761  }
3762}
3763
3764class MoonbeamAssetManagerGroup extends HelperGroup<MoonbeamHelper> {
3765  makeRegisterForeignAssetProposal(assetInfo: MoonbeamAssetInfo) {
3766    const apiPrefix = 'api.tx.assetManager.';
3767
3768    const registerTx = this.helper.constructApiCall(
3769      apiPrefix + 'registerForeignAsset',
3770      [assetInfo.location, assetInfo.metadata, assetInfo.existentialDeposit, assetInfo.isSufficient],
3771    );
3772
3773    const setUnitsTx = this.helper.constructApiCall(
3774      apiPrefix + 'setAssetUnitsPerSecond',
3775      [assetInfo.location, assetInfo.unitsPerSecond, assetInfo.numAssetsWeightHint],
3776    );
3777
3778    const batchCall = this.helper.getApi().tx.utility.batchAll([registerTx, setUnitsTx]);
3779    const encodedProposal = batchCall?.method.toHex() || '';
3780    return encodedProposal;
3781  }
3782
3783  async assetTypeId(location: any) {
3784    return await this.helper.callRpc('api.query.assetManager.assetTypeId', [location]);
3785  }
3786}
3787
3788class MoonbeamDemocracyGroup extends HelperGroup<MoonbeamHelper> {
3789  notePreimagePallet: string;
3790
3791  constructor(helper: MoonbeamHelper, options: { [key: string]: any } = {}) {
3792    super(helper);
3793    this.notePreimagePallet = options.notePreimagePallet;
3794  }
3795
3796  async notePreimage(signer: TSigner, encodedProposal: string) {
3797    await this.helper.executeExtrinsic(signer, `api.tx.${this.notePreimagePallet}.notePreimage`, [encodedProposal], true);
3798  }
3799
3800  externalProposeMajority(proposal: any) {
3801    return this.helper.constructApiCall('api.tx.democracy.externalProposeMajority', [proposal]);
3802  }
3803
3804  fastTrack(proposalHash: string, votingPeriod: number, delayPeriod: number) {
3805    return this.helper.constructApiCall('api.tx.democracy.fastTrack', [proposalHash, votingPeriod, delayPeriod]);
3806  }
3807
3808  async referendumVote(signer: TSigner, referendumIndex: number, accountVote: DemocracyStandardAccountVote) {
3809    await this.helper.executeExtrinsic(signer, 'api.tx.democracy.vote', [referendumIndex, {Standard: accountVote}], true);
3810  }
3811}
3812
3813class MoonbeamCollectiveGroup extends HelperGroup<MoonbeamHelper> {
3814  collective: string;
3815
3816  constructor(helper: MoonbeamHelper, collective: string) {
3817    super(helper);
3818
3819    this.collective = collective;
3820  }
3821
3822  async propose(signer: TSigner, threshold: number, proposalHash: string, lengthBound: number) {
3823    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.propose`, [threshold, proposalHash, lengthBound], true);
3824  }
3825
3826  async vote(signer: TSigner, proposalHash: string, proposalIndex: number, approve: boolean) {
3827    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.vote`, [proposalHash, proposalIndex, approve], true);
3828  }
3829
3830  async close(signer: TSigner, proposalHash: string, proposalIndex: number, weightBound: any, lengthBound: number) {
3831    await this.helper.executeExtrinsic(signer, `api.tx.${this.collective}.close`, [proposalHash, proposalIndex, weightBound, lengthBound], true);
3832  }
3833
3834  async proposalCount() {
3835    return Number(await this.helper.callRpc(`api.query.${this.collective}.proposalCount`, []));
3836  }
3837}
38383752
3839export type ChainHelperBaseConstructor = new (...args: any[]) => ChainHelperBase;3753export type ChainHelperBaseConstructor = new (...args: any[]) => ChainHelperBase;
3840export type UniqueHelperConstructor = new (...args: any[]) => UniqueHelper;3754export type UniqueHelperConstructor = new (...args: any[]) => UniqueHelper;
3891    this.utility = new UtilityGroup(this);3805    this.utility = new UtilityGroup(this);
3892  }3806  }
3893
3894  getSudo<T extends UniqueHelper>() {
3895    // eslint-disable-next-line @typescript-eslint/naming-convention
3896    const SudoHelperType = SudoHelper(this.helperBase);
3897    return this.clone(SudoHelperType) as T;
3898  }
3899}3807}
3900
3901export class XcmChainHelper extends ChainHelperBase {
3902  async connect(wsEndpoint: string, _listeners?: any): Promise<void> {
3903    const wsProvider = new WsProvider(wsEndpoint);
3904    this.api = new ApiPromise({
3905      provider: wsProvider,
3906    });
3907    await this.api.isReadyOrError;
3908    this.network = await UniqueHelper.detectNetwork(this.api);
3909  }
3910}
3911
3912export class RelayHelper extends XcmChainHelper {
3913  balance: SubstrateBalanceGroup<RelayHelper>;
3914  xcm: XcmGroup<RelayHelper>;
3915
3916  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
3917    super(logger, options.helperBase ?? RelayHelper);
3918
3919    this.balance = new SubstrateBalanceGroup(this);
3920    this.xcm = new XcmGroup(this, 'xcmPallet');
3921  }
3922}
3923
3924export class WestmintHelper extends XcmChainHelper {
3925  balance: SubstrateBalanceGroup<WestmintHelper>;
3926  xcm: XcmGroup<WestmintHelper>;
3927  assets: AssetsGroup<WestmintHelper>;
3928  xTokens: XTokensGroup<WestmintHelper>;
3929
3930  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
3931    super(logger, options.helperBase ?? WestmintHelper);
3932
3933    this.balance = new SubstrateBalanceGroup(this);
3934    this.xcm = new XcmGroup(this, 'polkadotXcm');
3935    this.assets = new AssetsGroup(this);
3936    this.xTokens = new XTokensGroup(this);
3937  }
3938}
3939
3940export class MoonbeamHelper extends XcmChainHelper {
3941  balance: EthereumBalanceGroup<MoonbeamHelper>;
3942  assetManager: MoonbeamAssetManagerGroup;
3943  assets: AssetsGroup<MoonbeamHelper>;
3944  xTokens: XTokensGroup<MoonbeamHelper>;
3945  democracy: MoonbeamDemocracyGroup;
3946  collective: {
3947    council: MoonbeamCollectiveGroup,
3948    techCommittee: MoonbeamCollectiveGroup,
3949  };
3950
3951  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
3952    super(logger, options.helperBase ?? MoonbeamHelper);
3953
3954    this.balance = new EthereumBalanceGroup(this);
3955    this.assetManager = new MoonbeamAssetManagerGroup(this);
3956    this.assets = new AssetsGroup(this);
3957    this.xTokens = new XTokensGroup(this);
3958    this.democracy = new MoonbeamDemocracyGroup(this, options);
3959    this.collective = {
3960      council: new MoonbeamCollectiveGroup(this, 'councilCollective'),
3961      techCommittee: new MoonbeamCollectiveGroup(this, 'techCommitteeCollective'),
3962    };
3963  }
3964}
3965
3966export class AstarHelper extends XcmChainHelper {
3967  balance: SubstrateBalanceGroup<AstarHelper>;
3968  assets: AssetsGroup<AstarHelper>;
3969  xcm: XcmGroup<AstarHelper>;
3970
3971  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
3972    super(logger, options.helperBase ?? AstarHelper);
3973
3974    this.balance = new SubstrateBalanceGroup(this);
3975    this.assets = new AssetsGroup(this);
3976    this.xcm = new XcmGroup(this, 'polkadotXcm');
3977  }
3978
3979  getSudo<T extends UniqueHelper>() {
3980    // eslint-disable-next-line @typescript-eslint/naming-convention
3981    const SudoHelperType = SudoHelper(this.helperBase);
3982    return this.clone(SudoHelperType) as T;
3983  }
3984}
3985
3986export class AcalaHelper extends XcmChainHelper {
3987  balance: SubstrateBalanceGroup<AcalaHelper>;
3988  assetRegistry: AcalaAssetRegistryGroup;
3989  xTokens: XTokensGroup<AcalaHelper>;
3990  tokens: TokensGroup<AcalaHelper>;
3991  xcm: XcmGroup<AcalaHelper>;
3992
3993  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
3994    super(logger, options.helperBase ?? AcalaHelper);
3995
3996    this.balance = new SubstrateBalanceGroup(this);
3997    this.assetRegistry = new AcalaAssetRegistryGroup(this);
3998    this.xTokens = new XTokensGroup(this);
3999    this.tokens = new TokensGroup(this);
4000    this.xcm = new XcmGroup(this, 'polkadotXcm');
4001  }
4002
4003  getSudo<T extends AcalaHelper>() {
4004    // eslint-disable-next-line @typescript-eslint/naming-convention
4005    const SudoHelperType = SudoHelper(this.helperBase);
4006    return this.clone(SudoHelperType) as T;
4007  }
4008}
4009
4010export class PolkadexHelper extends XcmChainHelper {
4011  assets: AssetsGroup<PolkadexHelper>;
4012  balance: SubstrateBalanceGroup<PolkadexHelper>;
4013  xTokens: XTokensGroup<PolkadexHelper>;
4014  xcm: XcmGroup<PolkadexHelper>;
4015  xcmHelper: PolkadexXcmHelperGroup<PolkadexHelper>;
4016
4017  constructor(logger?: ILogger, options: { [key: string]: any } = {}) {
4018    super(logger, options.helperBase ?? PolkadexHelper);
4019
4020    this.assets = new AssetsGroup(this);
4021    this.balance = new SubstrateBalanceGroup(this);
4022    this.xTokens = new XTokensGroup(this);
4023    this.xcm = new XcmGroup(this, 'polkadotXcm');
4024    this.xcmHelper = new PolkadexXcmHelperGroup(this);
4025  }
4026
4027  getSudo<T extends PolkadexHelper>() {
4028    // eslint-disable-next-line @typescript-eslint/naming-convention
4029    const SudoHelperType = SudoHelper(this.helperBase);
4030    return this.clone(SudoHelperType) as T;
4031  }
4032}
40333808
4034// eslint-disable-next-line @typescript-eslint/naming-convention3809// eslint-disable-next-line @typescript-eslint/naming-convention
4035function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {3810function ScheduledUniqueHelper<T extends UniqueHelperConstructor>(Base: T) {
4091  };3866  };
4092}3867}
4093
4094// eslint-disable-next-line @typescript-eslint/naming-convention
4095function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {
4096  return class extends Base {
4097    constructor(...args: any[]) {
4098      super(...args);
4099    }
4100
4101    async executeExtrinsic(
4102      sender: IKeyringPair,
4103      extrinsic: string,
4104      params: any[],
4105      expectSuccess?: boolean,
4106      options: Partial<SignerOptions> | null = null,
4107    ): Promise<ITransactionResult> {
4108      const call = this.constructApiCall(extrinsic, params);
4109      const result = await super.executeExtrinsic(
4110        sender,
4111        'api.tx.sudo.sudo',
4112        [call],
4113        expectSuccess,
4114        options,
4115      );
4116
4117      if(result.status === 'Fail') return result;
4118
4119      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;
4120      if(data.isErr) {
4121        if(data.asErr.isModule) {
4122          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;
4123          const metaError = super.getApi()?.registry.findMetaError(error);
4124          throw new Error(`${metaError.section}.${metaError.name}`);
4125        } else if(data.asErr.isToken) {
4126          throw new Error(`Token: ${data.asErr.asToken}`);
4127        }
4128        // May be [object Object] in case of unhandled non-unit enum
4129        throw new Error(`Misc: ${data.asErr.toHuman()}`);
4130      }
4131      return result;
4132    }
4133    async executeExtrinsicUncheckedWeight(
4134      sender: IKeyringPair,
4135      extrinsic: string,
4136      params: any[],
4137      expectSuccess?: boolean,
4138      options: Partial<SignerOptions> | null = null,
4139    ): Promise<ITransactionResult> {
4140      const call = this.constructApiCall(extrinsic, params);
4141      const result = await super.executeExtrinsic(
4142        sender,
4143        'api.tx.sudo.sudoUncheckedWeight',
4144        [call, {refTime: 0, proofSize: 0}],
4145        expectSuccess,
4146        options,
4147      );
4148
4149      if(result.status === 'Fail') return result;
4150
4151      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;
4152      if(data.isErr) {
4153        if(data.asErr.isModule) {
4154          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;
4155          const metaError = super.getApi()?.registry.findMetaError(error);
4156          throw new Error(`${metaError.section}.${metaError.name}`);
4157        } else if(data.asErr.isToken) {
4158          throw new Error(`Token: ${data.asErr.asToken}`);
4159        }
4160        // May be [object Object] in case of unhandled non-unit enum
4161        throw new Error(`Misc: ${data.asErr.toHuman()}`);
4162      }
4163      return result;
4164    }
4165  };
4166}
41673868
4168export class UniqueBaseCollection {3869export class UniqueBaseCollection {
4169  helper: UniqueHelper;3870  helper: UniqueHelper;
4290    return new UniqueBaseCollection(this.collectionId, scheduledHelper);3991    return new UniqueBaseCollection(this.collectionId, scheduledHelper);
4291  }3992  }
4292
4293  getSudo<T extends UniqueHelper>() {
4294    return new UniqueBaseCollection(this.collectionId, this.helper.getSudo<T>());
4295  }
4296}3993}
4297
42983994
4404    return new UniqueNFTCollection(this.collectionId, scheduledHelper);4100    return new UniqueNFTCollection(this.collectionId, scheduledHelper);
4405  }4101  }
4406
4407  getSudo<T extends UniqueHelper>() {
4408    return new UniqueNFTCollection(this.collectionId, this.helper.getSudo<T>());
4409  }
4410}4102}
4411
44124103
4530    return new UniqueRFTCollection(this.collectionId, scheduledHelper);4221    return new UniqueRFTCollection(this.collectionId, scheduledHelper);
4531  }4222  }
4532
4533  getSudo<T extends UniqueHelper>() {
4534    return new UniqueRFTCollection(this.collectionId, this.helper.getSudo<T>());
4535  }
4536}4223}
4537
45384224
4597    return new UniqueFTCollection(this.collectionId, scheduledHelper);4283    return new UniqueFTCollection(this.collectionId, scheduledHelper);
4598  }4284  }
4599
4600  getSudo<T extends UniqueHelper>() {
4601    return new UniqueFTCollection(this.collectionId, this.helper.getSudo<T>());
4602  }
4603}4285}
4604
46054286
4658    return new UniqueBaseToken(this.tokenId, scheduledCollection);4339    return new UniqueBaseToken(this.tokenId, scheduledCollection);
4659  }4340  }
4660
4661  getSudo<T extends UniqueHelper>() {
4662    return new UniqueBaseToken(this.tokenId, this.collection.getSudo<T>());
4663  }
4664}4341}
4665
46664342
4736    return new UniqueNFToken(this.tokenId, scheduledCollection);4412    return new UniqueNFToken(this.tokenId, scheduledCollection);
4737  }4413  }
4738
4739  getSudo<T extends UniqueHelper>() {
4740    return new UniqueNFToken(this.tokenId, this.collection.getSudo<T>());
4741  }
4742}4414}
47434415
4744export class UniqueRFToken extends UniqueBaseToken {4416export class UniqueRFToken extends UniqueBaseToken {
4825    return new UniqueRFToken(this.tokenId, scheduledCollection);4497    return new UniqueRFToken(this.tokenId, scheduledCollection);
4826  }4498  }
4827
4828  getSudo<T extends UniqueHelper>() {
4829    return new UniqueRFToken(this.tokenId, this.collection.getSudo<T>());
4830  }
4831}4499}
48324500