@cardano-sdk/e2e 0.36.0 → 0.36.2

package/test/wallet_epoch_0/PersonalWallet/conwayTransactions.test.ts

@@ -0,0 +1,470 @@
+import * as Crypto from '@cardano-sdk/crypto';
+import { BaseWallet } from '@cardano-sdk/wallet';
+import { Cardano, Serialization } from '@cardano-sdk/core';
+import { logger } from '@cardano-sdk/util-dev';
+
+import { firstValueFrom, map } from 'rxjs';
+import { getEnv, getWallet, submitAndConfirm, unDelegateWallet, walletReady, walletVariables } from '../../../src';
+
+/*
+Use cases not covered by specific tests because covered by (before|after)(All|Each) hooks
+- send RegisterDelegateRepresentative certificate
+  sent in beforeAll as a registered DRep is required to some other test cases
+- send UnregisterDelegateRepresentative certificate
+  sent in afterAll as test suite tear down
+- send Conway Registration certificate
+  sent in beforeEach in nested describe with tests requiring it
+- send ProposalProcedure
+  sent in beforeAll in nested describe to check VotingProcedure
+- send AuthorizeCommitteeHot
+  sent in beforeAll in nested describe to check UpdateDelegateRepresentative
+*/
+
+const {
+  CertificateType,
+  CredentialType,
+  GovernanceActionType,
+  RewardAccount,
+  StakeCredentialStatus,
+  StakePoolStatus,
+  Vote,
+  VoterType
+} = Cardano;
+
+const env = getEnv(walletVariables);
+
+const anchor = {
+  dataHash: '3e33018e8293d319ef5b3ac72366dd28006bd315b715f7e7cfcbd3004129b80d' as Crypto.Hash32ByteBase16,
+  url: 'https://testing.this'
+};
+
+const assertTxHasCertificate = (tx: Cardano.HydratedTx, certificate: Cardano.Certificate) =>
+  expect(tx.body.certificates![0]).toEqual(certificate);
+
+const getTestWallet = async (idx: number, name: string, minCoinBalance?: bigint) => {
+  const { wallet } = await getWallet({ env, idx, logger, name, polling: { interval: 50 } });
+
+  await walletReady(wallet, minCoinBalance);
+
+  return wallet;
+};
+
+// TODO: remove once mainnet hardforks to conway-era, and this becomes "the norm"
+describe.skip('PersonalWallet/conwayTransactions', () => {
+  let dRepWallet: BaseWallet;
+  let wallet: BaseWallet;
+
+  let dRepCredential: Cardano.Credential & { type: Cardano.CredentialType.KeyHash };
+  let poolId: Cardano.PoolId;
+  let rewardAccount: Cardano.RewardAccount;
+  let stakeCredential: Cardano.Credential;
+
+  let dRepDeposit: bigint;
+  let governanceActionDeposit: bigint;
+  let stakeKeyDeposit: bigint;
+
+  const assertWalletIsDelegating = async () =>
+    expect((await firstValueFrom(wallet.delegation.rewardAccounts$))[0].delegatee?.nextNextEpoch?.id).toEqual(poolId);
+
+  const getDRepCredential = async () => {
+    const drepPubKey = await dRepWallet.governance.getPubDRepKey();
+    const dRepKeyHash = Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(
+      (await Crypto.Ed25519PublicKey.fromHex(drepPubKey!).hash()).hex()
+    );
+
+    return { hash: dRepKeyHash, type: CredentialType.KeyHash } as typeof dRepCredential;
+  };
+
+  const getDeposits = async () => {
+    const protocolParameters = await wallet.networkInfoProvider.protocolParameters();
+
+    return [
+      BigInt(protocolParameters.dRepDeposit),
+      BigInt(protocolParameters.governanceActionDeposit),
+      BigInt(protocolParameters.stakeKeyDeposit)
+    ];
+  };
+
+  const getPoolId = async () => {
+    const activePools = await wallet.stakePoolProvider.queryStakePools({
+      filters: { status: [StakePoolStatus.Active] },
+      pagination: { limit: 1, startAt: 0 }
+    });
+
+    return activePools.pageResults[0].id;
+  };
+
+  const getStakeCredential = async () => {
+    rewardAccount = await firstValueFrom(wallet.addresses$.pipe(map((addresses) => addresses[0].rewardAccount)));
+
+    return {
+      hash: Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(RewardAccount.toHash(rewardAccount)),
+      type: CredentialType.KeyHash
+    };
+  };
+
+  // TODO LW-10555: Revert this to feed the dRep wallet, not the `wallet`, once the dbsync bug is fixed
+  // https://github.com/IntersectMBO/cardano-db-sync/issues/1702
+  const feedDRepWallet = async (amount: bigint) => {
+    const balance = await firstValueFrom(wallet.balance.utxo.total$);
+
+    if (balance.coins > amount) return;
+
+    const address = await firstValueFrom(wallet.addresses$.pipe(map((addresses) => addresses[0].address)));
+
+    const signedTx = await dRepWallet
+      .createTxBuilder()
+      .addOutput({ address, value: { coins: amount } })
+      .build()
+      .sign();
+
+    await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+  };
+
+  const sendDRepRegCert = async (register: boolean) => {
+    const common = { dRepCredential, deposit: dRepDeposit };
+    const dRepUnRegCert: Cardano.UnRegisterDelegateRepresentativeCertificate = {
+      __typename: CertificateType.UnregisterDelegateRepresentative,
+      ...common
+    };
+    const dRepRegCert: Cardano.RegisterDelegateRepresentativeCertificate = {
+      __typename: CertificateType.RegisterDelegateRepresentative,
+      anchor,
+      ...common
+    };
+    const certificate = register ? dRepRegCert : dRepUnRegCert;
+    const signedTx = await dRepWallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [certificate] }))
+      .build()
+      .sign();
+    const [, confirmedTx] = await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+
+    assertTxHasCertificate(confirmedTx, certificate);
+  };
+
+  const isRegisteredDRep = async () => {
+    const txs = [...(await firstValueFrom(dRepWallet.transactions.history$))].reverse();
+
+    for (const {
+      body: { certificates }
+    } of txs) {
+      if (certificates) {
+        for (const certificate of certificates) {
+          if (certificate.__typename === CertificateType.UnregisterDelegateRepresentative) return false;
+          if (certificate.__typename === CertificateType.RegisterDelegateRepresentative) return true;
+        }
+      }
+    }
+
+    return false;
+  };
+
+  beforeAll(async () => {
+    // TODO: remove once mainnet hardforks to conway-era, and this becomes "the norm"
+    Serialization.CborSet.useConwaySerialization = true;
+    Serialization.Redeemers.useConwaySerialization = true;
+
+    // TODO LW-10555: Revert this so that wallet is at account 0 and drepWallet at account 1, once the dbsync bug is fixed
+    // https://github.com/IntersectMBO/cardano-db-sync/issues/1702
+    [dRepWallet, wallet] = await Promise.all([
+      getTestWallet(0, 'Conway DRep Wallet', 100_000_000n),
+      getTestWallet(1, 'Conway Wallet', 0n)
+    ]);
+
+    [dRepCredential, [dRepDeposit, governanceActionDeposit, stakeKeyDeposit], poolId, stakeCredential] =
+      await Promise.all([getDRepCredential(), getDeposits(), getPoolId(), getStakeCredential()]);
+
+    // TODO LW-10555: Revert this to use the 2*drepDeposit, once the dbsync bug is fixed
+    // https://github.com/IntersectMBO/cardano-db-sync/issues/1702
+    await feedDRepWallet(governanceActionDeposit * 6n + 100_000_000n);
+
+    if (!(await isRegisteredDRep())) await sendDRepRegCert(true);
+  });
+
+  beforeEach(async () => await unDelegateWallet(wallet));
+
+  afterAll(async () => {
+    await sendDRepRegCert(false);
+    await unDelegateWallet(wallet);
+
+    wallet.shutdown();
+    dRepWallet.shutdown();
+
+    // TODO: remove once mainnet hardforks to conway-era, and this becomes "the norm"
+    Serialization.CborSet.useConwaySerialization = false;
+    Serialization.Redeemers.useConwaySerialization = false;
+  });
+
+  it('can register a stake key and delegate stake using a combo certificate', async () => {
+    const regAndDelegCert: Cardano.StakeRegistrationDelegationCertificate = {
+      __typename: CertificateType.StakeRegistrationDelegation,
+      deposit: stakeKeyDeposit,
+      poolId,
+      stakeCredential
+    };
+    const signedTx = await wallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [regAndDelegCert] }))
+      .build()
+      .sign();
+    const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+    assertTxHasCertificate(confirmedTx, regAndDelegCert);
+    await assertWalletIsDelegating();
+  });
+
+  it('can register a stake key and delegate vote using a combo certificate', async () => {
+    const regAndVoteDelegCert: Cardano.VoteRegistrationDelegationCertificate = {
+      __typename: CertificateType.VoteRegistrationDelegation,
+      dRep: dRepCredential,
+      deposit: stakeKeyDeposit,
+      stakeCredential
+    };
+    const signedTx = await wallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [regAndVoteDelegCert] }))
+      .build()
+      .sign();
+    const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+    assertTxHasCertificate(confirmedTx, regAndVoteDelegCert);
+  });
+
+  it('can register a stake key and delegate stake and vote using a combo certificate', async () => {
+    const regStakeVoteDelegCert: Cardano.StakeVoteRegistrationDelegationCertificate = {
+      __typename: CertificateType.StakeVoteRegistrationDelegation,
+      dRep: dRepCredential,
+      deposit: stakeKeyDeposit,
+      poolId,
+      stakeCredential
+    };
+    const signedTx = await wallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [regStakeVoteDelegCert] }))
+      .build()
+      .sign();
+    const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+    assertTxHasCertificate(confirmedTx, regStakeVoteDelegCert);
+    await assertWalletIsDelegating();
+  });
+
+  it('can update delegation representatives', async () => {
+    const updateDRepCert: Cardano.UpdateDelegateRepresentativeCertificate = {
+      __typename: CertificateType.UpdateDelegateRepresentative,
+      anchor: null,
+      dRepCredential
+    };
+    const signedTx = await dRepWallet
+      .createTxBuilder()
+      .customize(({ txBody }) => ({ ...txBody, certificates: [updateDRepCert] }))
+      .build()
+      .sign();
+    const [, confirmedTx] = await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+
+    assertTxHasCertificate(confirmedTx, updateDRepCert);
+  });
+
+  // TODO LW-9962
+  describe.skip('with constitutional committee', () => {
+    beforeAll(async () => {
+      const regCCCert: Cardano.AuthorizeCommitteeHotCertificate = {
+        __typename: CertificateType.AuthorizeCommitteeHot,
+        coldCredential: stakeCredential,
+        hotCredential: stakeCredential
+      };
+      const signedTx = await dRepWallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, certificates: [regCCCert] }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+
+      assertTxHasCertificate(confirmedTx, regCCCert);
+    });
+
+    it('can update delegation representatives', async () => {
+      const updateDRepCert: Cardano.UpdateDelegateRepresentativeCertificate = {
+        __typename: CertificateType.UpdateDelegateRepresentative,
+        anchor,
+        dRepCredential
+      };
+      const signedTx = await dRepWallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, certificates: [updateDRepCert] }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+
+      assertTxHasCertificate(confirmedTx, updateDRepCert);
+    });
+  });
+
+  describe('with Conway Registration certificate', () => {
+    beforeEach(async () => {
+      const newRegCert: Cardano.NewStakeAddressCertificate = {
+        __typename: CertificateType.Registration,
+        deposit: stakeKeyDeposit,
+        stakeCredential
+      };
+      const signedTx = await wallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, certificates: [newRegCert] }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+      assertTxHasCertificate(confirmedTx, newRegCert);
+      expect((await firstValueFrom(wallet.delegation.rewardAccounts$))[0].credentialStatus).toBe(
+        StakeCredentialStatus.Registered
+      );
+    });
+
+    it('can un-register stake key through the new Conway certificates', async () => {
+      const newUnRegCert: Cardano.NewStakeAddressCertificate = {
+        __typename: CertificateType.Unregistration,
+        deposit: stakeKeyDeposit,
+        stakeCredential
+      };
+      const signedTx = await wallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, certificates: [newUnRegCert] }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+      assertTxHasCertificate(confirmedTx, newUnRegCert);
+      expect((await firstValueFrom(wallet.delegation.rewardAccounts$))[0].credentialStatus).toBe(
+        StakeCredentialStatus.Unregistered
+      );
+    });
+
+    it('can delegate vote', async () => {
+      const voteDelegCert: Cardano.VoteDelegationCertificate = {
+        __typename: CertificateType.VoteDelegation,
+        dRep: dRepCredential,
+        stakeCredential
+      };
+      const signedTx = await wallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, certificates: [voteDelegCert] }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+      assertTxHasCertificate(confirmedTx, voteDelegCert);
+      await assertWalletIsDelegating();
+    });
+
+    it('can delegate stake and vote using combo certificate', async () => {
+      const stakeVoteDelegCert: Cardano.StakeVoteDelegationCertificate = {
+        __typename: CertificateType.StakeVoteDelegation,
+        dRep: dRepCredential,
+        poolId,
+        stakeCredential
+      };
+      const signedTx = await wallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, certificates: [stakeVoteDelegCert] }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+      assertTxHasCertificate(confirmedTx, stakeVoteDelegCert);
+      await assertWalletIsDelegating();
+    });
+  });
+
+  describe('with proposal procedure', () => {
+    let actionId: Cardano.GovernanceActionId;
+
+    beforeAll(async () => {
+      const proposalProcedures: Cardano.ProposalProcedure[] = [
+        {
+          anchor,
+          deposit: governanceActionDeposit,
+          governanceAction: {
+            __typename: GovernanceActionType.parameter_change_action,
+            governanceActionId: null,
+            policyHash: null,
+            protocolParamUpdate: { maxTxSize: 2000 }
+          },
+          rewardAccount
+        },
+        {
+          anchor,
+          deposit: governanceActionDeposit,
+          governanceAction: {
+            __typename: GovernanceActionType.hard_fork_initiation_action,
+            governanceActionId: null,
+            protocolVersion: { major: 10, minor: 0 }
+          },
+          rewardAccount
+        },
+        {
+          anchor,
+          deposit: governanceActionDeposit,
+          governanceAction: {
+            __typename: GovernanceActionType.treasury_withdrawals_action,
+            policyHash: null,
+            withdrawals: new Set([{ coin: 10_000_000n, rewardAccount }])
+          },
+          rewardAccount
+        },
+        {
+          anchor,
+          deposit: governanceActionDeposit,
+          governanceAction: {
+            __typename: GovernanceActionType.no_confidence,
+            governanceActionId: null
+          },
+          rewardAccount
+        },
+        {
+          anchor,
+          deposit: governanceActionDeposit,
+          governanceAction: {
+            __typename: GovernanceActionType.new_constitution,
+            constitution: { anchor, scriptHash: null },
+            governanceActionId: null
+          },
+          rewardAccount
+        },
+        {
+          anchor,
+          deposit: governanceActionDeposit,
+          governanceAction: { __typename: GovernanceActionType.info_action },
+          rewardAccount
+        }
+      ];
+      const signedTx = await wallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, proposalProcedures }))
+        .build()
+        .sign();
+      const [id, confirmedTx] = await submitAndConfirm(wallet, signedTx.tx, 1);
+
+      expect(confirmedTx.body.proposalProcedures).toEqual(proposalProcedures);
+
+      actionId = { actionIndex: 0, id };
+    });
+
+    it('delegation representatives can vote proposal procedure', async () => {
+      const votingProcedures: Cardano.VotingProcedures = [
+        {
+          voter: { __typename: VoterType.dRepKeyHash, credential: dRepCredential },
+          votes: [{ actionId, votingProcedure: { anchor, vote: Vote.abstain } }]
+        }
+      ];
+      const signedTx = await dRepWallet
+        .createTxBuilder()
+        .customize(({ txBody }) => ({ ...txBody, votingProcedures }))
+        .build()
+        .sign();
+      const [, confirmedTx] = await submitAndConfirm(dRepWallet, signedTx.tx, 1);
+
+      expect(confirmedTx.body.votingProcedures).toEqual(votingProcedures);
+    });
+  });
+});

package/test/wallet_epoch_0/PersonalWallet/multisignature.test.ts

@@ -2,7 +2,7 @@
 import { BaseWallet, FinalizeTxProps } from '@cardano-sdk/wallet';
 import { Cardano, nativeScriptPolicyId } from '@cardano-sdk/core';
 import { InitializeTxProps } from '@cardano-sdk/tx-construction';
-import { KeyRole, util } from '@cardano-sdk/key-management';
+import { KeyPurpose, KeyRole, util } from '@cardano-sdk/key-management';
 import {
   bip32Ed25519Factory,
   burnTokens,
@@ -48,12 +48,14 @@ describe('PersonalWallet/multisignature', () => {
     const aliceKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      bip32Ed25519
+      bip32Ed25519,
+      KeyPurpose.MULTI_SIG
     );
     const bobKeyAgent = await createStandaloneKeyAgent(
       env.KEY_MANAGEMENT_PARAMS.mnemonic.split(' '),
       genesis,
-      bip32Ed25519
+      bip32Ed25519,
+      KeyPurpose.MULTI_SIG
     );
 
     const aliceDerivationPath = {

package/test/wallet_epoch_0/PersonalWallet/phase2validation.test.ts

@@ -70,7 +70,10 @@ describe('PersonalWallet/phase2validation', () => {
     wallet.shutdown();
   });
 
-  it('can detect a phase2 validation failure and emit the transaction as failed', async () => {
+  // The submit fails instead of being able to send it.
+  // TODO: re-enable this after understanding how to force submit API to submit a transaction that
+  // will fain in phase2 validation
+  it.skip('can detect a phase2 validation failure and emit the transaction as failed', async () => {
     wallet = (await getWallet({ env, logger, name: 'Minting Wallet', polling: { interval: 50 } })).wallet;
 
     // Plutus script that always returns false.

package/test/wallet_epoch_0/PersonalWallet/plutusTest.test.ts

@@ -184,7 +184,8 @@ const getScriptUtxoSet = (
     )
   );
 
-describe('PersonalWallet/plutus', () => {
+// LW-10693: disable until costModels are fetched from protocolParams
+describe.skip('PersonalWallet/plutus', () => {
   let wallet: BaseWallet;
   afterAll(() => {
     wallet.shutdown();

package/test/wallet_epoch_0/SharedWallet/utils.ts

@@ -2,6 +2,7 @@ import * as Crypto from '@cardano-sdk/crypto';
 import {
   AccountKeyDerivationPath,
   KeyAgent,
+  KeyPurpose,
   KeyRole,
   SignBlobResult,
   SignDataContext,
@@ -30,7 +31,12 @@ const getKeyAgent = async (
   genesisParameters: Cardano.CompactGenesis,
   bip32Ed25519: Crypto.Bip32Ed25519
 ) => {
-  const keyAgent = await createStandaloneKeyAgent(mnemonics.split(' '), genesisParameters, bip32Ed25519);
+  const keyAgent = await createStandaloneKeyAgent(
+    mnemonics.split(' '),
+    genesisParameters,
+    bip32Ed25519,
+    KeyPurpose.MULTI_SIG
+  );
 
   const pubKey = await keyAgent.derivePublicKey(DERIVATION_PATH);
 

package/test/wallet_epoch_3/PersonalWallet/delegationDistribution.test.ts

@@ -105,19 +105,20 @@ const delegateToMultiplePools = async (
   return { poolIds, portfolio };
 };
 
-const delegateAllToSinglePool = async (wallet: BaseWallet): Promise<void> => {
+const delegateAllToSinglePool = async (wallet: BaseWallet): Promise<Cardano.StakePool> => {
   // This is a negative testcase, simulating an HD wallet that has multiple stake keys delegated
   // to the same stake pool. txBuilder.delegatePortfolio does not support this scenario.
-  const [{ id: poolId }] = await getPoolIds(wallet);
+  const [pool] = await getPoolIds(wallet);
   const txBuilder = wallet.createTxBuilder();
   const rewardAccounts = await firstValueFrom(wallet.delegation.rewardAccounts$);
   txBuilder.partialTxBody.certificates = rewardAccounts.map(({ address }) =>
-    Cardano.createDelegationCert(address, poolId)
+    Cardano.createDelegationCert(address, pool.id)
   );
 
-  logger.debug(`Delegating all stake keys to pool ${poolId}`);
+  logger.debug(`Delegating all stake keys to pool ${pool.id}`);
   const { tx } = await txBuilder.build().sign();
   await submitAndConfirm(wallet, tx);
+  return pool;
 };
 
 describe('PersonalWallet/delegationDistribution', () => {
@@ -216,11 +217,11 @@ describe('PersonalWallet/delegationDistribution', () => {
     );
 
     // Delegate all reward accounts to the same pool. delegationDistribution$ should have 1 entry with 100% distribution
-    await delegateAllToSinglePool(wallet);
+    const pool = await delegateAllToSinglePool(wallet);
     simplifiedDelegationDistribution = await firstValueFrom(
       wallet.delegation.distribution$.pipe(
         tap((distribution) => {
-          logger.info('All stake keys are delegated to poolId:', poolIds[0].id);
+          logger.info('All stake keys are delegated to poolId:', pool.id);
           logger.info(distributionMessage, distribution);
         }),
         map((distribution) =>
@@ -236,8 +237,8 @@ describe('PersonalWallet/delegationDistribution', () => {
 
     expect(simplifiedDelegationDistribution).toEqual([
       {
-        id: poolIds[0].id,
-        name: poolIds[0].metadata?.name,
+        id: pool.id,
+        name: pool.metadata?.name,
         percentage: Percent(1),
         rewardAccounts: rewardAccounts.map(({ address }) => address)
       }

package/test/web-extension/webpack.config.base.js

@@ -70,7 +70,9 @@ module.exports = {
     resolve: {
       extensions: ['.ts', '.js'],
       fallback: {
+        '@cardano-sdk/cardano-services': false,
         buffer: require.resolve('buffer/'),
+        crypto: require.resolve('crypto-browserify'),
         events: require.resolve('events/'),
         fs: false,
         'get-port-please': false,
@@ -79,7 +81,6 @@ module.exports = {
         os: false,
         path: false,
         perf_hooks: false,
-        crypto: require.resolve('crypto-browserify'),
         stream: require.resolve('readable-stream'),
         util: require.resolve('util/')
       }