Class AssetLabelingClient

Type declaration

• addLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [id: string, name: string, url: string]
              | { id: string; name: string; url: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the add_label(string,string,string)void ABI method.

• addLabelToAsset: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [label: string, asset: bigint] | { asset: bigint; label: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the add_label_to_asset(string,asset)void ABI method.

• addLabelToAssets: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [label: string, assets: number[] | bigint[]]
              | { assets: number[] | bigint[]; label: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the add_label_to_assets(string,uint64[])void ABI method.

• addOperatorToLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [operator: string | Uint8Array<ArrayBufferLike>, label: string]
              | { label: string; operator: string | Uint8Array<ArrayBufferLike> };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the add_operator_to_label(account,string)void ABI method.

• changeAdmin: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [newAdmin: string | Uint8Array<ArrayBufferLike>]
              | { newAdmin: string | Uint8Array<ArrayBufferLike> };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the change_admin(account)void ABI method.

• changeLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [id: string, name: string, url: string]
              | { id: string; name: string; url: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the change_label(string,string,string)void ABI method.

• clearState: (
      params?: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args?: Uint8Array<ArrayBufferLike>[];
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      },
  ) => Promise<Transaction>

  Makes a clear_state call to an existing instance of the AssetLabeling smart contract.

• delete: {
      bare: (
          params?: {
              accountReferences?: string[];
              appReferences?: bigint[];
              args?: Uint8Array<ArrayBufferLike>[];
              assetReferences?: bigint[];
              boxReferences?: (BoxIdentifier | BoxReference)[];
              extraFee?: AlgoAmount;
              firstValidRound?: bigint;
              lastValidRound?: bigint;
              lease?: string | Uint8Array<ArrayBufferLike>;
              maxFee?: AlgoAmount;
              note?: string | Uint8Array<ArrayBufferLike>;
              rekeyTo?: string;
              sender?: string;
              signer?: TransactionSigner | TransactionSignerAccount;
              staticFee?: AlgoAmount;
              validityWindow?: number;
          },
      ) => Promise<Transaction>;
  }

  Gets available delete methods

  • bare: (
        params?: {
            accountReferences?: string[];
            appReferences?: bigint[];
            args?: Uint8Array<ArrayBufferLike>[];
            assetReferences?: bigint[];
            boxReferences?: (BoxIdentifier | BoxReference)[];
            extraFee?: AlgoAmount;
            firstValidRound?: bigint;
            lastValidRound?: bigint;
            lease?: string | Uint8Array<ArrayBufferLike>;
            maxFee?: AlgoAmount;
            note?: string | Uint8Array<ArrayBufferLike>;
            rekeyTo?: string;
            sender?: string;
            signer?: TransactionSigner | TransactionSignerAccount;
            staticFee?: AlgoAmount;
            validityWindow?: number;
        },
    ) => Promise<Transaction>

    Deletes an existing instance of the AssetLabeling smart contract using a bare call.

• getAssetFull: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_full(uint64)(string,string,string,uint64,uint8,address,address,address,address,address,bool,byte[],uint64,string[]) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: bigint] | { asset: bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_labels(asset)string[] ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetMicro: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_micro(uint64)(string,uint8) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetMicroLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_micro_labels(uint64)(string,uint8,string[]) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsFull: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_full(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_labels(uint64[])string[][] ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetSmall: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_small(uint64)(string,string,uint8,uint64,bool,bool,string[]) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsMicro: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_micro(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsMicroLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_micro_labels(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsSmall: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_small(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsText: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_text(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsTextLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_text_labels(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsTiny: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_tiny(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetsTinyLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_assets_tiny_labels(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetText: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_text(uint64)(string,string,string) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetTextLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_text_labels(uint64)(string,string,string,string[]) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetTiny: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_tiny(uint64)(string,string,uint8) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getAssetTinyLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [asset: number | bigint] | { asset: number | bigint };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_asset_tiny_labels(uint64)(string,string,uint8,string[]) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [id: string] | { id: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_label(string)(string,string,uint64,uint64) ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• getOperatorLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [operator: string | Uint8Array<ArrayBufferLike>]
              | { operator: string | Uint8Array<ArrayBufferLike> };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the get_operator_labels(account)string[] ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• hasAssetLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [assetId: number | bigint, label: string]
              | { assetId: number | bigint; label: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the has_asset_label(uint64,string)uint64 ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• hasLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [id: string] | { id: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the has_label(string)uint64 ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• hasOperatorLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [operator: string | Uint8Array<ArrayBufferLike>, label: string]
              | { label: string; operator: string | Uint8Array<ArrayBufferLike> };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the has_operator_label(account,string)uint64 ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• logAssetsLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [assets: number[] | bigint[]] | { assets: number[] | bigint[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the log_assets_labels(uint64[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• logLabels: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [ids: string[]] | { ids: string[] };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the log_labels(string[])void ABI method.

  This method is a readonly method; calling it with onComplete of NoOp will result in a simulated transaction rather than a real transaction.

• removeLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [id: string] | { id: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the remove_label(string)void ABI method.

• removeLabelFromAsset: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args: [label: string, asset: bigint] | { asset: bigint; label: string };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the remove_label_from_asset(string,asset)void ABI method.

• removeOperatorFromLabel: (
      params: {
          accountReferences?: string[];
          appReferences?: bigint[];
          args:
              | [operator: string | Uint8Array<ArrayBufferLike>, label: string]
              | { label: string; operator: string | Uint8Array<ArrayBufferLike> };
          assetReferences?: bigint[];
          boxReferences?: (BoxIdentifier | BoxReference)[];
          extraFee?: AlgoAmount;
          firstValidRound?: bigint;
          lastValidRound?: bigint;
          lease?: string | Uint8Array<ArrayBufferLike>;
          maxFee?: AlgoAmount;
          note?: string | Uint8Array<ArrayBufferLike>;
          rekeyTo?: string;
          sender?: string;
          signer?: TransactionSigner | TransactionSignerAccount;
          staticFee?: AlgoAmount;
          validityWindow?: number;
      } & { onComplete?: NoOpOC },
  ) => Promise<
      {
          methodCalls: Map<number, ABIMethod>;
          signers: Map<number, TransactionSigner>;
          transactions: Transaction[];
      },
  >

  Makes a call to the AssetLabeling smart contract using the remove_operator_from_label(account,string)void ABI method.

• update: {
      bare: (
          params?: {
              accountReferences?: string[];
              appReferences?: bigint[];
              args?: Uint8Array<ArrayBufferLike>[];
              assetReferences?: bigint[];
              boxReferences?: (BoxIdentifier | BoxReference)[];
              deletable?: boolean;
              deployTimeParams?: TealTemplateParams;
              extraFee?: AlgoAmount;
              firstValidRound?: bigint;
              lastValidRound?: bigint;
              lease?: string | Uint8Array<ArrayBufferLike>;
              maxFee?: AlgoAmount;
              note?: string | Uint8Array<ArrayBufferLike>;
              rekeyTo?: string;
              sender?: string;
              signer?: TransactionSigner | TransactionSignerAccount;
              staticFee?: AlgoAmount;
              updatable?: boolean;
              validityWindow?: number;
          },
      ) => Promise<Transaction>;
  }

  Gets available update methods

  • bare: (
        params?: {
            accountReferences?: string[];
            appReferences?: bigint[];
            args?: Uint8Array<ArrayBufferLike>[];
            assetReferences?: bigint[];
            boxReferences?: (BoxIdentifier | BoxReference)[];
            deletable?: boolean;
            deployTimeParams?: TealTemplateParams;
            extraFee?: AlgoAmount;
            firstValidRound?: bigint;
            lastValidRound?: bigint;
            lease?: string | Uint8Array<ArrayBufferLike>;
            maxFee?: AlgoAmount;
            note?: string | Uint8Array<ArrayBufferLike>;
            rekeyTo?: string;
            sender?: string;
            signer?: TransactionSigner | TransactionSignerAccount;
            staticFee?: AlgoAmount;
            updatable?: boolean;
            validityWindow?: number;
        },
    ) => Promise<Transaction>

    Updates an existing instance of the AssetLabeling smart contract using a bare call.