feat: update getWalletHistory. (#1216)

.changeset/fuzzy-moose-yawn.md

@@ -0,0 +1,7 @@
+---
+'@moralisweb3/common-evm-utils': patch
+'@moralisweb3/evm-api': patch
+'moralis': patch
+---
+
+Update the return types of the `getWalletHistory` method.

packages/common/evmUtils/src/generated/types/EvmCommonContractData.ts

@@ -0,0 +1,64 @@
+import { EvmContractTokenDetails, EvmContractTokenDetailsInput, EvmContractTokenDetailsJSON } from '../types/EvmContractTokenDetails';
+import { EvmContractSpenderDetails, EvmContractSpenderDetailsInput, EvmContractSpenderDetailsJSON } from '../types/EvmContractSpenderDetails';
+
+// $ref: #/components/schemas/CommonContractData
+// type: CommonContractData
+// properties:
+// - value ($ref: #/components/schemas/CommonContractData/properties/value)
+// - value_formatted ($ref: #/components/schemas/CommonContractData/properties/value_formatted)
+// - token ($ref: #/components/schemas/ContractTokenDetails)
+// - spender ($ref: #/components/schemas/ContractSpenderDetails)
+
+export interface EvmCommonContractDataJSON {
+  readonly value: string;
+  readonly value_formatted?: string;
+  readonly token: EvmContractTokenDetailsJSON;
+  readonly spender: EvmContractSpenderDetailsJSON;
+}
+
+export interface EvmCommonContractDataInput {
+  readonly value: string;
+  readonly valueFormatted?: string;
+  readonly token: EvmContractTokenDetailsInput | EvmContractTokenDetails;
+  readonly spender: EvmContractSpenderDetailsInput | EvmContractSpenderDetails;
+}
+
+export class EvmCommonContractData {
+  public static create(input: EvmCommonContractDataInput | EvmCommonContractData): EvmCommonContractData {
+    if (input instanceof EvmCommonContractData) {
+      return input;
+    }
+    return new EvmCommonContractData(input);
+  }
+
+  public static fromJSON(json: EvmCommonContractDataJSON): EvmCommonContractData {
+    const input: EvmCommonContractDataInput = {
+      value: json.value,
+      valueFormatted: json.value_formatted,
+      token: EvmContractTokenDetails.fromJSON(json.token),
+      spender: EvmContractSpenderDetails.fromJSON(json.spender),
+    };
+    return EvmCommonContractData.create(input);
+  }
+
+  public readonly value: string;
+  public readonly valueFormatted?: string;
+  public readonly token: EvmContractTokenDetails;
+  public readonly spender: EvmContractSpenderDetails;
+
+  private constructor(input: EvmCommonContractDataInput) {
+    this.value = input.value;
+    this.valueFormatted = input.valueFormatted;
+    this.token = EvmContractTokenDetails.create(input.token);
+    this.spender = EvmContractSpenderDetails.create(input.spender);
+  }
+
+  public toJSON(): EvmCommonContractDataJSON {
+    return {
+      value: this.value,
+      value_formatted: this.valueFormatted,
+      token: this.token.toJSON(),
+      spender: this.spender.toJSON(),
+    }
+  }
+}

packages/common/evmUtils/src/generated/types/EvmContractSpenderDetails.ts

@@ -0,0 +1,70 @@
+import { EvmAddress, EvmAddressInput, EvmAddressJSON } from '../../dataTypes';
+
+// $ref: #/components/schemas/ContractSpenderDetails
+// type: ContractSpenderDetails
+// properties:
+// - address ($ref: #/components/schemas/ContractSpenderDetails/properties/address)
+// - address_label ($ref: #/components/schemas/ContractSpenderDetails/properties/address_label)
+// - name ($ref: #/components/schemas/ContractSpenderDetails/properties/name)
+// - symbol ($ref: #/components/schemas/ContractSpenderDetails/properties/symbol)
+// - logo ($ref: #/components/schemas/ContractSpenderDetails/properties/logo)
+
+export interface EvmContractSpenderDetailsJSON {
+  readonly address: EvmAddressJSON;
+  readonly address_label?: string;
+  readonly name?: string;
+  readonly symbol?: string;
+  readonly logo?: string;
+}
+
+export interface EvmContractSpenderDetailsInput {
+  readonly address: EvmAddressInput | EvmAddress;
+  readonly addressLabel?: string;
+  readonly name?: string;
+  readonly symbol?: string;
+  readonly logo?: string;
+}
+
+export class EvmContractSpenderDetails {
+  public static create(input: EvmContractSpenderDetailsInput | EvmContractSpenderDetails): EvmContractSpenderDetails {
+    if (input instanceof EvmContractSpenderDetails) {
+      return input;
+    }
+    return new EvmContractSpenderDetails(input);
+  }
+
+  public static fromJSON(json: EvmContractSpenderDetailsJSON): EvmContractSpenderDetails {
+    const input: EvmContractSpenderDetailsInput = {
+      address: EvmAddress.fromJSON(json.address),
+      addressLabel: json.address_label,
+      name: json.name,
+      symbol: json.symbol,
+      logo: json.logo,
+    };
+    return EvmContractSpenderDetails.create(input);
+  }
+
+  public readonly address: EvmAddress;
+  public readonly addressLabel?: string;
+  public readonly name?: string;
+  public readonly symbol?: string;
+  public readonly logo?: string;
+
+  private constructor(input: EvmContractSpenderDetailsInput) {
+    this.address = EvmAddress.create(input.address);
+    this.addressLabel = input.addressLabel;
+    this.name = input.name;
+    this.symbol = input.symbol;
+    this.logo = input.logo;
+  }
+
+  public toJSON(): EvmContractSpenderDetailsJSON {
+    return {
+      address: this.address.toJSON(),
+      address_label: this.addressLabel,
+      name: this.name,
+      symbol: this.symbol,
+      logo: this.logo,
+    }
+  }
+}

packages/common/evmUtils/src/generated/types/EvmContractTokenDetails.ts

@@ -0,0 +1,70 @@
+import { EvmAddress, EvmAddressInput, EvmAddressJSON } from '../../dataTypes';
+
+// $ref: #/components/schemas/ContractTokenDetails
+// type: ContractTokenDetails
+// properties:
+// - address ($ref: #/components/schemas/ContractTokenDetails/properties/address)
+// - address_label ($ref: #/components/schemas/ContractTokenDetails/properties/address_label)
+// - token_name ($ref: #/components/schemas/ContractTokenDetails/properties/token_name)
+// - token_logo ($ref: #/components/schemas/ContractTokenDetails/properties/token_logo)
+// - token_symbol ($ref: #/components/schemas/ContractTokenDetails/properties/token_symbol)
+
+export interface EvmContractTokenDetailsJSON {
+  readonly address: EvmAddressJSON;
+  readonly address_label?: string;
+  readonly token_name: string;
+  readonly token_logo: string;
+  readonly token_symbol: string;
+}
+
+export interface EvmContractTokenDetailsInput {
+  readonly address: EvmAddressInput | EvmAddress;
+  readonly addressLabel?: string;
+  readonly tokenName: string;
+  readonly tokenLogo: string;
+  readonly tokenSymbol: string;
+}
+
+export class EvmContractTokenDetails {
+  public static create(input: EvmContractTokenDetailsInput | EvmContractTokenDetails): EvmContractTokenDetails {
+    if (input instanceof EvmContractTokenDetails) {
+      return input;
+    }
+    return new EvmContractTokenDetails(input);
+  }
+
+  public static fromJSON(json: EvmContractTokenDetailsJSON): EvmContractTokenDetails {
+    const input: EvmContractTokenDetailsInput = {
+      address: EvmAddress.fromJSON(json.address),
+      addressLabel: json.address_label,
+      tokenName: json.token_name,
+      tokenLogo: json.token_logo,
+      tokenSymbol: json.token_symbol,
+    };
+    return EvmContractTokenDetails.create(input);
+  }
+
+  public readonly address: EvmAddress;
+  public readonly addressLabel?: string;
+  public readonly tokenName: string;
+  public readonly tokenLogo: string;
+  public readonly tokenSymbol: string;
+
+  private constructor(input: EvmContractTokenDetailsInput) {
+    this.address = EvmAddress.create(input.address);
+    this.addressLabel = input.addressLabel;
+    this.tokenName = input.tokenName;
+    this.tokenLogo = input.tokenLogo;
+    this.tokenSymbol = input.tokenSymbol;
+  }
+
+  public toJSON(): EvmContractTokenDetailsJSON {
+    return {
+      address: this.address.toJSON(),
+      address_label: this.addressLabel,
+      token_name: this.tokenName,
+      token_logo: this.tokenLogo,
+      token_symbol: this.tokenSymbol,
+    }
+  }
+}

packages/common/evmUtils/src/generated/types/EvmDefiPositionDetails.ts

@@ -27,6 +27,9 @@ import { EvmDefiPositionDetailsNftMetadata, EvmDefiPositionDetailsNftMetadataVal
 // - factory ($ref: #/components/schemas/defiPositionDetails/properties/factory)
 // - pair ($ref: #/components/schemas/defiPositionDetails/properties/pair)
 // - share_of_pool ($ref: #/components/schemas/defiPositionDetails/properties/share_of_pool)
+// - no_price_available ($ref: #/components/schemas/defiPositionDetails/properties/no_price_available)
+// - shares_in_strategy ($ref: #/components/schemas/defiPositionDetails/properties/shares_in_strategy)
+// - strategy_address ($ref: #/components/schemas/defiPositionDetails/properties/strategy_address)
 
 export interface EvmDefiPositionDetailsJSON {
   readonly fee_tier?: number;
@@ -53,6 +56,9 @@ export interface EvmDefiPositionDetailsJSON {
   readonly factory?: string;
   readonly pair?: string;
   readonly share_of_pool?: number;
+  readonly no_price_available?: boolean;
+  readonly shares_in_strategy?: string;
+  readonly strategy_address?: string;
 }
 
 export interface EvmDefiPositionDetailsInput {
@@ -80,6 +86,9 @@ export interface EvmDefiPositionDetailsInput {
   readonly factory?: string;
   readonly pair?: string;
   readonly shareOfPool?: number;
+  readonly noPriceAvailable?: boolean;
+  readonly sharesInStrategy?: string;
+  readonly strategyAddress?: string;
 }
 
 export class EvmDefiPositionDetails {
@@ -116,6 +125,9 @@ export class EvmDefiPositionDetails {
       factory: json.factory,
       pair: json.pair,
       shareOfPool: json.share_of_pool,
+      noPriceAvailable: json.no_price_available,
+      sharesInStrategy: json.shares_in_strategy,
+      strategyAddress: json.strategy_address,
     };
     return EvmDefiPositionDetails.create(input);
   }
@@ -216,6 +228,18 @@ export class EvmDefiPositionDetails {
    * @description The share of the pool
    */
   public readonly shareOfPool?: number;
+  /**
+   * @description Whether the price is available
+   */
+  public readonly noPriceAvailable?: boolean;
+  /**
+   * @description The shares in the strategy
+   */
+  public readonly sharesInStrategy?: string;
+  /**
+   * @description The address of the strategy
+   */
+  public readonly strategyAddress?: string;
 
   private constructor(input: EvmDefiPositionDetailsInput) {
     this.feeTier = input.feeTier;
@@ -242,6 +266,9 @@ export class EvmDefiPositionDetails {
     this.factory = input.factory;
     this.pair = input.pair;
     this.shareOfPool = input.shareOfPool;
+    this.noPriceAvailable = input.noPriceAvailable;
+    this.sharesInStrategy = input.sharesInStrategy;
+    this.strategyAddress = input.strategyAddress;
   }
 
   public toJSON(): EvmDefiPositionDetailsJSON {
@@ -270,6 +297,9 @@ export class EvmDefiPositionDetails {
       factory: this.factory,
       pair: this.pair,
       share_of_pool: this.shareOfPool,
+      no_price_available: this.noPriceAvailable,
+      shares_in_strategy: this.sharesInStrategy,
+      strategy_address: this.strategyAddress,
     }
   }
 }

packages/common/evmUtils/src/generated/types/EvmResolveContractInteractionResponse.ts

@@ -0,0 +1,63 @@
+import { EvmCommonContractData, EvmCommonContractDataInput, EvmCommonContractDataJSON } from '../types/EvmCommonContractData';
+
+// $ref: #/components/schemas/ResolveContractInteractionResponse
+// type: ResolveContractInteractionResponse
+// properties:
+// - approvals ($ref: #/components/schemas/CommonContractData)
+// - revokes ($ref: #/components/schemas/CommonContractData)
+// - approvalsAll ($ref: #/components/schemas/CommonContractData)
+// - revokesAll ($ref: #/components/schemas/CommonContractData)
+
+export interface EvmResolveContractInteractionResponseJSON {
+  readonly approvals?: EvmCommonContractDataJSON[];
+  readonly revokes?: EvmCommonContractDataJSON[];
+  readonly approvalsAll?: EvmCommonContractDataJSON[];
+  readonly revokesAll?: EvmCommonContractDataJSON[];
+}
+
+export interface EvmResolveContractInteractionResponseInput {
+  readonly approvals?: EvmCommonContractDataInput[] | EvmCommonContractData[];
+  readonly revokes?: EvmCommonContractDataInput[] | EvmCommonContractData[];
+  readonly approvalsAll?: EvmCommonContractDataInput[] | EvmCommonContractData[];
+  readonly revokesAll?: EvmCommonContractDataInput[] | EvmCommonContractData[];
+}
+
+export class EvmResolveContractInteractionResponse {
+  public static create(input: EvmResolveContractInteractionResponseInput | EvmResolveContractInteractionResponse): EvmResolveContractInteractionResponse {
+    if (input instanceof EvmResolveContractInteractionResponse) {
+      return input;
+    }
+    return new EvmResolveContractInteractionResponse(input);
+  }
+
+  public static fromJSON(json: EvmResolveContractInteractionResponseJSON): EvmResolveContractInteractionResponse {
+    const input: EvmResolveContractInteractionResponseInput = {
+      approvals: json.approvals ? json.approvals.map((item) => EvmCommonContractData.fromJSON(item)) : undefined,
+      revokes: json.revokes ? json.revokes.map((item) => EvmCommonContractData.fromJSON(item)) : undefined,
+      approvalsAll: json.approvalsAll ? json.approvalsAll.map((item) => EvmCommonContractData.fromJSON(item)) : undefined,
+      revokesAll: json.revokesAll ? json.revokesAll.map((item) => EvmCommonContractData.fromJSON(item)) : undefined,
+    };
+    return EvmResolveContractInteractionResponse.create(input);
+  }
+
+  public readonly approvals?: EvmCommonContractData[];
+  public readonly revokes?: EvmCommonContractData[];
+  public readonly approvalsAll?: EvmCommonContractData[];
+  public readonly revokesAll?: EvmCommonContractData[];
+
+  private constructor(input: EvmResolveContractInteractionResponseInput) {
+    this.approvals = input.approvals ? input.approvals.map((item) => EvmCommonContractData.create(item)) : undefined;
+    this.revokes = input.revokes ? input.revokes.map((item) => EvmCommonContractData.create(item)) : undefined;
+    this.approvalsAll = input.approvalsAll ? input.approvalsAll.map((item) => EvmCommonContractData.create(item)) : undefined;
+    this.revokesAll = input.revokesAll ? input.revokesAll.map((item) => EvmCommonContractData.create(item)) : undefined;
+  }
+
+  public toJSON(): EvmResolveContractInteractionResponseJSON {
+    return {
+      approvals: this.approvals ? this.approvals.map((item) => item.toJSON()) : undefined,
+      revokes: this.revokes ? this.revokes.map((item) => item.toJSON()) : undefined,
+      approvalsAll: this.approvalsAll ? this.approvalsAll.map((item) => item.toJSON()) : undefined,
+      revokesAll: this.revokesAll ? this.revokesAll.map((item) => item.toJSON()) : undefined,
+    }
+  }
+}