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

--- a/.envrc
+++ b/.envrc
@@ -30,7 +30,7 @@
     fi
 
     echo -e "${GREEN}Baedeker env updated${RESET}"
-    nginx_id=$(docker compose -f .baedeker/.bdk-env/docker-compose.yml ps --format=json | jq -r '.[] | select(.Service == "nginx") | .ID' -e)
+    nginx_id=$(docker compose -f .baedeker/.bdk-env/docker-compose.yml ps --format=json | jq -s 'flatten' | jq -r '.[] | select(.Service == "nginx") | .ID' -e)
     if ! [ $? -eq 0 ]; then
         echo -e "${RED}Nginx container not found${RESET}"
         exit 0

--- a/tests/src/util/playgrounds/types.ts
+++ b/tests/src/util/playgrounds/types.ts
@@ -223,36 +223,6 @@
   minimalBalance?: bigint,
 }
 
-export interface MoonbeamAssetInfo {
-  location: any,
-  metadata: {
-    name: string,
-    symbol: string,
-    decimals: number,
-    isFrozen: boolean,
-    minimalBalance: bigint,
-  },
-  existentialDeposit: bigint,
-  isSufficient: boolean,
-  unitsPerSecond: bigint,
-  numAssetsWeightHint: number,
-}
-
-export interface AcalaAssetMetadata {
-  name: string,
-  symbol: string,
-  decimals: number,
-  minimalBalance: bigint,
-}
-
-export interface DemocracyStandardAccountVote {
-  balance: bigint,
-  vote: {
-    aye: boolean,
-    conviction: number,
-  },
-}
-
 export interface DemocracySplitAccount {
   aye: bigint,
   nay: bigint,

--- a/tests/src/util/playgrounds/unique.dev.ts
+++ b/tests/src/util/playgrounds/unique.dev.ts
@@ -3,16 +3,17 @@
 
 import {stringToU8a} from '@polkadot/util';
 import {blake2AsHex, encodeAddress, mnemonicGenerate} from '@polkadot/util-crypto';
-import {UniqueHelper, MoonbeamHelper, ChainHelperBase, AcalaHelper, RelayHelper, WestmintHelper, AstarHelper, PolkadexHelper} from './unique';
+import {UniqueHelper, ChainHelperBase, ChainHelperBaseConstructor} from './unique';
 import {ApiPromise, Keyring, WsProvider} from '@polkadot/api';
 import * as defs from '../../interfaces/definitions';
 import {IKeyringPair} from '@polkadot/types/types';
 import {EventRecord} from '@polkadot/types/interfaces';
 import {ICrossAccountId, IPovInfo, ITransactionResult, TSigner} from './types';
 import {FrameSystemEventRecord, XcmV2TraitsError} from '@polkadot/types/lookup';
-import {VoidFn} from '@polkadot/api/types';
+import {SignerOptions, VoidFn} from '@polkadot/api/types';
 import {Pallets} from '..';
 import {spawnSync} from 'child_process';
+import {AcalaHelper, AstarHelper, MoonbeamHelper, PolkadexHelper, RelayHelper, WestmintHelper} from './unique.xcm';
 
 export class SilentLogger {
   log(_msg: any, _level: any): void { }
@@ -260,6 +261,80 @@
   };
 }
 
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function SudoHelper<T extends ChainHelperBaseConstructor>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...args);
+    }
+
+    async executeExtrinsic(
+      sender: IKeyringPair,
+      extrinsic: string,
+      params: any[],
+      expectSuccess?: boolean,
+      options: Partial<SignerOptions> | null = null,
+    ): Promise<ITransactionResult> {
+      const call = this.constructApiCall(extrinsic, params);
+      const result = await super.executeExtrinsic(
+        sender,
+        'api.tx.sudo.sudo',
+        [call],
+        expectSuccess,
+        options,
+      );
+
+      if(result.status === 'Fail') return result;
+
+      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;
+      if(data.isErr) {
+        if(data.asErr.isModule) {
+          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;
+          const metaError = super.getApi()?.registry.findMetaError(error);
+          throw new Error(`${metaError.section}.${metaError.name}`);
+        } else if(data.asErr.isToken) {
+          throw new Error(`Token: ${data.asErr.asToken}`);
+        }
+        // May be [object Object] in case of unhandled non-unit enum
+        throw new Error(`Misc: ${data.asErr.toHuman()}`);
+      }
+      return result;
+    }
+    async executeExtrinsicUncheckedWeight(
+      sender: IKeyringPair,
+      extrinsic: string,
+      params: any[],
+      expectSuccess?: boolean,
+      options: Partial<SignerOptions> | null = null,
+    ): Promise<ITransactionResult> {
+      const call = this.constructApiCall(extrinsic, params);
+      const result = await super.executeExtrinsic(
+        sender,
+        'api.tx.sudo.sudoUncheckedWeight',
+        [call, {refTime: 0, proofSize: 0}],
+        expectSuccess,
+        options,
+      );
+
+      if(result.status === 'Fail') return result;
+
+      const data = (result.result.events.find(x => x.event.section == 'sudo' && x.event.method == 'Sudid')?.event.data as any).sudoResult;
+      if(data.isErr) {
+        if(data.asErr.isModule) {
+          const error = (result.result.events[1].event.data as any).sudoResult.asErr.asModule;
+          const metaError = super.getApi()?.registry.findMetaError(error);
+          throw new Error(`${metaError.section}.${metaError.name}`);
+        } else if(data.asErr.isToken) {
+          throw new Error(`Token: ${data.asErr.asToken}`);
+        }
+        // May be [object Object] in case of unhandled non-unit enum
+        throw new Error(`Misc: ${data.asErr.toHuman()}`);
+      }
+      return result;
+    }
+  };
+}
+
 export class DevUniqueHelper extends UniqueHelper {
   /**
    * Arrange methods for tests
@@ -326,6 +401,11 @@
     this.network = await UniqueHelper.detectNetwork(this.api);
     this.wsEndpoint = wsEndpoint;
   }
+  getSudo<T extends UniqueHelper>() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const SudoHelperType = SudoHelper(this.helperBase);
+    return this.clone(SudoHelperType) as T;
+  }
 }
 
 export class DevRelayHelper extends RelayHelper {
@@ -386,6 +466,12 @@
     super(logger, options);
     this.wait = new WaitGroup(this);
   }
+
+  getSudo<T extends UniqueHelper>() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const SudoHelperType = SudoHelper(this.helperBase);
+    return this.clone(SudoHelperType) as T;
+  }
 }
 
 export class DevShidenHelper extends AstarHelper {
@@ -408,6 +494,11 @@
     super(logger, options);
     this.wait = new WaitGroup(this);
   }
+  getSudo<T extends UniqueHelper>() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const SudoHelperType = SudoHelper(this.helperBase);
+    return this.clone(SudoHelperType) as T;
+  }
 }
 
 export class DevPolkadexHelper extends PolkadexHelper {
@@ -418,6 +509,12 @@
     super(logger, options);
     this.wait = new WaitGroup(this);
   }
+
+  getSudo<T extends PolkadexHelper>() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const SudoHelperType = SudoHelper(this.helperBase);
+    return this.clone(SudoHelperType) as T;
+  }
 }
 
 export 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