Skip to main content

Assets

Represents a list of non-Ada tokens.

export interface Assets {
  add(other: Assets): Assets
  addAssetClassQuantity(
    assetClass: AssetClassLike,
    qty: IntLike
  ): void
  addPolicyTokenQuantity(
    mph: MintingPolicyHashLike,
    tokenName: BytesLike,
    qty: IntLike
  ): void
  addPolicyTokens(
    mph: MintingPolicyHashLike,
    tokens: [BytesLike, IntLike][]
  ): void
  assertAllPositive(): void
  assertSorted(): void
  assetClasses: AssetClass<unknown>[]
  assets: [MintingPolicyHash<unknown>, [number[], bigint][]][]
  copy(): Assets
  countTokens(): number
  dump(): any
  getAssetClassQuantity(assetClass: AssetClassLike): bigint
  getPolicies(): MintingPolicyHash<unknown>[]
  getPolicyTokenNames(policy: MintingPolicyHashLike): number[][]
  getPolicyTokenQuantity(
    mph: MintingPolicyHashLike,
    tokenName: BytesLike
  ): bigint
  getPolicyTokens(policy: MintingPolicyHashLike): [number[], bigint][]
  hasAssetClass(assetClass: AssetClassLike): boolean
  hasPolicyToken(
    mph: MintingPolicyHashLike,
    tokenName: BytesLike
  ): boolean
  isAllPositive(): boolean
  isEqual(other: Assets): boolean
  isGreaterOrEqual(other: Assets): boolean
  isGreaterThan(other: Assets): boolean
  isZero(): boolean
  kind: "Assets"
  multiply(scalar: IntLike): Assets
  normalize(): void
  removeZeroes(): void
  sort(): void
  subtract(other: Assets): Assets
  toCbor(): number[]
  toUplcData(): MapData
}

Properties​

add​

assets.add satisfies (other: Assets) => Assets

addAssetClassQuantity​

Mutates this

assets.addAssetClassQuantity satisfies (
  assetClass: AssetClassLike,
  qty: IntLike
) => void

addPolicyTokenQuantity​

Mutates this

assets.addPolicyTokenQuantity satisfies (
  mph: MintingPolicyHashLike,
  tokenName: BytesLike,
  qty: IntLike
) => void

addPolicyTokens​

Mutates 'this'. Throws error if mph is already contained in 'this'.

assets.addPolicyTokens satisfies (
  mph: MintingPolicyHashLike,
  tokens: [BytesLike, IntLike][]
) => void

assertAllPositive​

Throws an error if any contained quantity <= 0n

assets.assertAllPositive satisfies () => void

assertSorted​

assets.assertSorted satisfies () => void

assetClasses​

assets.assetClasses satisfies AssetClass<unknown>[]

assets​

assets.assets satisfies [MintingPolicyHash<unknown>, [number[], bigint][]][]

copy​

assets.copy satisfies () => Assets

countTokens​

Returns the number of unique tokens

assets.countTokens satisfies () => number

dump​

assets.dump satisfies () => any

getAssetClassQuantity​

Returns 0n if not found

assets.getAssetClassQuantity satisfies (assetClass: AssetClassLike) => bigint

getPolicies​

Returns a list of all the minting policies.

assets.getPolicies satisfies () => MintingPolicyHash<unknown>[]

getPolicyTokenNames​

Returns an empty list if the policy isn't found

assets.getPolicyTokenNames satisfies (policy: MintingPolicyHashLike) => number[][]

getPolicyTokenQuantity​

Returns 0n if not found

assets.getPolicyTokenQuantity satisfies (
  mph: MintingPolicyHashLike,
  tokenName: BytesLike
) => bigint

getPolicyTokens​

Returns an empty list if the policy isn't found

assets.getPolicyTokens satisfies (policy: MintingPolicyHashLike) => [number[], bigint][]

hasAssetClass​

assets.hasAssetClass satisfies (assetClass: AssetClassLike) => boolean

hasPolicyToken​

assets.hasPolicyToken satisfies (
  mph: MintingPolicyHashLike,
  tokenName: BytesLike
) => boolean

isAllPositive​

assets.isAllPositive satisfies () => boolean

isEqual​

assets.isEqual satisfies (other: Assets) => boolean

isGreaterOrEqual​

assets.isGreaterOrEqual satisfies (other: Assets) => boolean

isGreaterThan​

assets.isGreaterThan satisfies (other: Assets) => boolean

isZero​

assets.isZero satisfies () => boolean

kind​

assets.kind satisfies "Assets"

multiply​

assets.multiply satisfies (scalar: IntLike) => Assets

normalize​

Removes zeroes and merges duplicates. In-place algorithm. Keeps the same order as much as possible.

assets.normalize satisfies () => void

removeZeroes​

Mutates this

assets.removeZeroes satisfies () => void

sort​

Makes sure minting policies are in correct order, and for each minting policy make sure the tokens are in the correct order Mutates this

assets.sort satisfies () => void

subtract​

assets.subtract satisfies (other: Assets) => Assets

toCbor​

assets.toCbor satisfies () => number[]

toUplcData​

Used when generating script contexts for running programs

assets.toUplcData satisfies () => MapData