@shipload/sdk 1.0.0-next.13 → 1.0.0-next.15

package/src/nft/atomicassets.ts

@@ -0,0 +1,108 @@
+import {type APIClient, Name, type NameType, UInt64} from '@wharfkit/antelope'
+import {deserializeAtomicData, type SchemaField} from './atomicdata'
+import {deserializeAsset, type NFTCargoItem, type NFTModuleSlot} from './deserializers'
+
+export const ATOMICASSETS_ACCOUNT = 'atomicassets'
+export const SHIPLOAD_COLLECTION = 'shipload'
+
+export interface AtomicAssetRow {
+    asset_id: string
+    collection_name: string
+    schema_name: string
+    template_id: number
+    ram_payer?: string
+    backed_tokens?: string[]
+    immutable_serialized_data: string | number[]
+    mutable_serialized_data?: string | number[]
+}
+
+export interface AtomicSchemaRow {
+    schema_name: string
+    format: SchemaField[]
+}
+
+export interface FetchAssetsOptions {
+    collection?: NameType
+    pageSize?: number
+}
+
+export async function fetchAtomicAssetsForOwner(
+    client: APIClient,
+    owner: NameType,
+    opts: FetchAssetsOptions = {}
+): Promise<AtomicAssetRow[]> {
+    const collection = opts.collection ? String(Name.from(opts.collection)) : undefined
+    const pageSize = opts.pageSize ?? 1000
+    const out: AtomicAssetRow[] = []
+    let lower: UInt64 | undefined
+    while (true) {
+        const res = await client.v1.chain.get_table_rows({
+            code: Name.from(ATOMICASSETS_ACCOUNT),
+            scope: String(Name.from(owner)),
+            table: Name.from('assets'),
+            limit: pageSize,
+            lower_bound: lower,
+            json: true,
+        })
+        for (const row of res.rows as AtomicAssetRow[]) {
+            if (!collection || row.collection_name === collection) out.push(row)
+        }
+        if (!res.more) break
+        lower = UInt64.from(String(res.next_key))
+    }
+    return out
+}
+
+export async function fetchAtomicSchemas(
+    client: APIClient,
+    collection: NameType
+): Promise<AtomicSchemaRow[]> {
+    const out: AtomicSchemaRow[] = []
+    let lower: Name | undefined
+    while (true) {
+        const res = await client.v1.chain.get_table_rows({
+            code: Name.from(ATOMICASSETS_ACCOUNT),
+            scope: String(Name.from(collection)),
+            table: Name.from('schemas'),
+            limit: 100,
+            lower_bound: lower,
+            json: true,
+        })
+        for (const row of res.rows as AtomicSchemaRow[]) out.push(row)
+        if (!res.more) break
+        lower = Name.from(String(res.next_key))
+    }
+    return out
+}
+
+export interface DecodedAtomicAsset {
+    asset_id: bigint
+    schema_name: string
+    template_id: number
+    item_id: number
+    quantity: number
+    stats: string
+    origin_x: bigint
+    origin_y: bigint
+    modules?: NFTModuleSlot[]
+}
+
+export function decodeAtomicAsset(
+    asset: AtomicAssetRow,
+    schemaFormat: SchemaField[],
+    itemId: number
+): DecodedAtomicAsset {
+    const data = deserializeAtomicData(asset.immutable_serialized_data, schemaFormat)
+    const cargo: NFTCargoItem = deserializeAsset(data, itemId)
+    return {
+        asset_id: BigInt(String(asset.asset_id)),
+        schema_name: String(asset.schema_name),
+        template_id: Number(asset.template_id),
+        item_id: cargo.item_id,
+        quantity: cargo.quantity,
+        stats: cargo.stats,
+        origin_x: BigInt(String(data.origin_x ?? 0)),
+        origin_y: BigInt(String(data.origin_y ?? 0)),
+        modules: cargo.modules,
+    }
+}

package/src/nft/index.ts

@@ -1,3 +1,4 @@
 export * from './deserializers'
 export * from './description'
 export * from './atomicdata'
+export * from './atomicassets'

package/src/resolution/display-name.ts

@@ -1,22 +1,44 @@
 import type {ResolvedItem} from './resolve-item'
 import type {ResourceCategory} from '../types'
-import {CATEGORY_LABELS, TIER_ADJECTIVES} from '../types'
+import {
+    CATEGORY_LABELS,
+    RESOURCE_TIER_ADJECTIVES,
+    COMPONENT_TIER_PREFIXES,
+    MODULE_TIER_PREFIXES,
+} from '../types'
 import {formatMass as defaultFormatMass} from '../format'
 
-export interface DisplayNameInput {
-    itemType: 'resource' | 'component' | 'module' | 'entity' | string
+interface DisplayNameInputCommon {
     tier: number
     category?: ResourceCategory
     name: string
 }
 
-export function displayName(resolved: DisplayNameInput): string {
-    if (resolved.itemType === 'resource') {
-        const adj = TIER_ADJECTIVES[resolved.tier] ?? 'Unknown'
-        const cat = resolved.category ? CATEGORY_LABELS[resolved.category] : 'Resource'
-        return `${adj} ${cat}`
-    }
-    return resolved.name
+export type DisplayNameInput =
+    | (DisplayNameInputCommon & {itemType: 'resource' | 'component' | 'module' | 'entity' | string})
+    | (DisplayNameInputCommon & {type: string})
+
+function itemTypeOf(item: DisplayNameInput): string {
+    return 'itemType' in item ? item.itemType : item.type
+}
+
+function tierPrefix(item: DisplayNameInput): string | null {
+    const t = itemTypeOf(item)
+    if (t === 'resource') return RESOURCE_TIER_ADJECTIVES[item.tier] ?? null
+    if (t === 'component') return COMPONENT_TIER_PREFIXES[item.tier] ?? null
+    if (t === 'module') return MODULE_TIER_PREFIXES[item.tier] ?? null
+    return null
+}
+
+function baseName(item: DisplayNameInput): string {
+    if (itemTypeOf(item) !== 'resource') return item.name
+    return item.category ? CATEGORY_LABELS[item.category] : 'Resource'
+}
+
+export function displayName(item: DisplayNameInput): string {
+    const prefix = tierPrefix(item)
+    const head = prefix ? `${prefix} ${baseName(item)}` : baseName(item)
+    return `${head} (T${item.tier})`
 }
 
 export interface DescribeOptions {

package/src/types.ts

@@ -120,7 +120,7 @@ export type ModuleType =
     | 'storage'
     | 'hauler'
 
-export const TIER_ADJECTIVES: Record<number, string> = {
+export const RESOURCE_TIER_ADJECTIVES: Record<number, string> = {
     1: 'Crude',
     2: 'Dense',
     3: 'Pure',
@@ -133,6 +133,9 @@ export const TIER_ADJECTIVES: Record<number, string> = {
     10: 'Ascendant',
 }
 
+export const COMPONENT_TIER_PREFIXES: Record<number, string> = {}
+export const MODULE_TIER_PREFIXES: Record<number, string> = {}
+
 export const CATEGORY_LABELS: Record<ResourceCategory, string> = {
     ore: 'Ore',
     crystal: 'Crystal',
@@ -158,5 +161,5 @@ export function formatTier(tier: number): string {
 }
 
 export function tierAdjective(tier: number): string {
-    return TIER_ADJECTIVES[tier] ?? `T${tier}`
+    return RESOURCE_TIER_ADJECTIVES[tier] ?? `T${tier}`
 }