@shipload/sdk 1.0.0-next.3 → 1.0.0-next.31

package/src/nft/atomicassets.ts

@@ -0,0 +1,237 @@
+import {
+    ABI,
+    type ABIDef,
+    Action,
+    type APIClient,
+    type NameType,
+    Name,
+    PermissionLevel,
+    UInt64,
+} from '@wharfkit/antelope'
+import {deserializeAtomicData, type SchemaField} from './atomicdata'
+import {deserializeAsset, type NFTCargoItem, type NFTModuleSlot} from './deserializers'
+import type {ImmutableEntry} from './buildImmutableData'
+import atomicAssetsAbi from './atomicassets.abi.json'
+
+const PLACEHOLDER_AUTH = PermissionLevel.from({
+    actor: '............1',
+    permission: '............2',
+})
+
+export const ATOMICASSETS_ACCOUNT = 'atomicassets'
+export const SHIPLOAD_COLLECTION = 'shipload'
+
+export const ATOMICASSETS_ABI = ABI.from(atomicAssetsAbi as ABIDef)
+
+const ATOMIC_ATTRIBUTE_VARIANT_NAME =
+    'variant_int8_int16_int32_int64_uint8_uint16_uint32_uint64_float32_float64_string_INT8_VEC_INT16_VEC_INT32_VEC_INT64_VEC_UINT8_VEC_UINT16_VEC_UINT32_VEC_UINT64_VEC_FLOAT_VEC_DOUBLE_VEC_STRING_VEC'
+
+const MINTASSET_ABI_DEF: ABIDef = {
+    version: 'eosio::abi/1.2',
+    types: [
+        {new_type_name: 'ATOMIC_ATTRIBUTE', type: ATOMIC_ATTRIBUTE_VARIANT_NAME},
+        {new_type_name: 'ATTRIBUTE_MAP', type: 'pair_string_ATOMIC_ATTRIBUTE[]'},
+        {new_type_name: 'INT8_VEC', type: 'bytes'},
+        {new_type_name: 'INT16_VEC', type: 'int16[]'},
+        {new_type_name: 'INT32_VEC', type: 'int32[]'},
+        {new_type_name: 'INT64_VEC', type: 'int64[]'},
+        {new_type_name: 'UINT8_VEC', type: 'bytes'},
+        {new_type_name: 'UINT16_VEC', type: 'uint16[]'},
+        {new_type_name: 'UINT32_VEC', type: 'uint32[]'},
+        {new_type_name: 'UINT64_VEC', type: 'uint64[]'},
+        {new_type_name: 'FLOAT_VEC', type: 'float32[]'},
+        {new_type_name: 'DOUBLE_VEC', type: 'float64[]'},
+        {new_type_name: 'STRING_VEC', type: 'string[]'},
+    ],
+    structs: [
+        {
+            name: 'pair_string_ATOMIC_ATTRIBUTE',
+            base: '',
+            fields: [
+                {name: 'first', type: 'string'},
+                {name: 'second', type: 'ATOMIC_ATTRIBUTE'},
+            ],
+        },
+        {
+            name: 'mintasset',
+            base: '',
+            fields: [
+                {name: 'authorized_minter', type: 'name'},
+                {name: 'collection_name', type: 'name'},
+                {name: 'schema_name', type: 'name'},
+                {name: 'template_id', type: 'int32'},
+                {name: 'new_asset_owner', type: 'name'},
+                {name: 'immutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'mutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'tokens_to_back', type: 'asset[]'},
+            ],
+        },
+    ],
+    actions: [{name: 'mintasset', type: 'mintasset', ricardian_contract: ''}],
+    variants: [
+        {
+            name: ATOMIC_ATTRIBUTE_VARIANT_NAME,
+            types: [
+                'int8',
+                'int16',
+                'int32',
+                'int64',
+                'uint8',
+                'uint16',
+                'uint32',
+                'uint64',
+                'float32',
+                'float64',
+                'string',
+                'INT8_VEC',
+                'INT16_VEC',
+                'INT32_VEC',
+                'INT64_VEC',
+                'UINT8_VEC',
+                'UINT16_VEC',
+                'UINT32_VEC',
+                'UINT64_VEC',
+                'FLOAT_VEC',
+                'DOUBLE_VEC',
+                'STRING_VEC',
+            ],
+        },
+    ],
+}
+
+export interface MintAssetParams {
+    authorizedMinter: NameType
+    collectionName: NameType
+    schemaName: NameType
+    templateId: number
+    newAssetOwner: NameType
+    immutableData: ImmutableEntry[]
+}
+
+const MINTASSET_ABI = ABI.from(MINTASSET_ABI_DEF)
+
+export function buildMintAssetAction(params: MintAssetParams): Action {
+    return Action.from(
+        {
+            account: Name.from(ATOMICASSETS_ACCOUNT),
+            name: Name.from('mintasset'),
+            authorization: [PLACEHOLDER_AUTH],
+            data: {
+                authorized_minter: Name.from(params.authorizedMinter),
+                collection_name: Name.from(params.collectionName),
+                schema_name: Name.from(params.schemaName),
+                template_id: params.templateId,
+                new_asset_owner: Name.from(params.newAssetOwner),
+                immutable_data: params.immutableData,
+                mutable_data: [],
+                tokens_to_back: [],
+            },
+        },
+        MINTASSET_ABI
+    )
+}
+
+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
+    account?: NameType
+}
+
+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 account = Name.from(opts.account ?? ATOMICASSETS_ACCOUNT)
+    const out: AtomicAssetRow[] = []
+    let lower: UInt64 | undefined
+    while (true) {
+        const res = await client.v1.chain.get_table_rows({
+            code: 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,
+    account: NameType = ATOMICASSETS_ACCOUNT
+): Promise<AtomicSchemaRow[]> {
+    const out: AtomicSchemaRow[] = []
+    let lower: Name | undefined
+    while (true) {
+        const res = await client.v1.chain.get_table_rows({
+            code: Name.from(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/atomicdata.ts

@@ -0,0 +1,130 @@
+export interface SchemaField {
+    name: string
+    type: string
+}
+
+export type RawData =
+    | Uint8Array
+    | string
+    | number[]
+    | {immutable_serialized_data: Uint8Array | string | number[]}
+
+export function deserializeAtomicData(
+    data: RawData,
+    schema: SchemaField[]
+): Record<string, unknown> {
+    let rawData: Uint8Array | string | number[]
+    if (data && typeof data === 'object' && 'immutable_serialized_data' in (data as object)) {
+        rawData = (data as {immutable_serialized_data: Uint8Array | string | number[]})
+            .immutable_serialized_data
+    } else {
+        rawData = data as Uint8Array | string | number[]
+    }
+
+    let bytes: Uint8Array
+    if (typeof rawData === 'string') {
+        const hex = rawData
+        bytes = new Uint8Array(hex.length / 2)
+        for (let i = 0; i < hex.length; i += 2) {
+            bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16)
+        }
+    } else if (Array.isArray(rawData)) {
+        bytes = new Uint8Array(rawData)
+    } else {
+        bytes = rawData
+    }
+
+    let offset = 0
+
+    function readVarint(): number {
+        let result = 0
+        let multiplier = 1
+        while (bytes[offset] >= 128) {
+            result += (bytes[offset] - 128) * multiplier
+            offset++
+            multiplier *= 128
+        }
+        result += bytes[offset] * multiplier
+        offset++
+        return result
+    }
+
+    function readVarint64(): bigint {
+        let result = 0n
+        let multiplier = 1n
+        while (bytes[offset] >= 128) {
+            result += BigInt(bytes[offset] - 128) * multiplier
+            offset++
+            multiplier *= 128n
+        }
+        result += BigInt(bytes[offset]) * multiplier
+        offset++
+        return result
+    }
+
+    function readZigzagInt64(): bigint {
+        const unsigned = readVarint64()
+        if (unsigned % 2n === 0n) {
+            return unsigned / 2n
+        } else {
+            return -(unsigned / 2n) - 1n
+        }
+    }
+
+    function readString(): string {
+        const length = readVarint()
+        const str = new TextDecoder().decode(bytes.slice(offset, offset + length))
+        offset += length
+        return str
+    }
+
+    const RESERVED = 4
+    const result: Record<string, unknown> = {}
+
+    while (offset < bytes.length) {
+        const fieldIndex = readVarint() - RESERVED
+        const field = schema[fieldIndex]
+        if (!field) break
+
+        switch (field.type) {
+            case 'uint16':
+                result[field.name] = readVarint()
+                break
+            case 'uint32':
+                result[field.name] = readVarint()
+                break
+            case 'uint64':
+                result[field.name] = readVarint64()
+                break
+            case 'int32':
+                result[field.name] = readZigzagInt64()
+                break
+            case 'int64':
+                result[field.name] = readZigzagInt64()
+                break
+            case 'string':
+            case 'image':
+            case 'ipfs':
+                result[field.name] = readString()
+                break
+            case 'uint16[]': {
+                const len = readVarint()
+                const arr: number[] = []
+                for (let i = 0; i < len; i++) arr.push(readVarint())
+                result[field.name] = arr
+                break
+            }
+            case 'uint64[]': {
+                const len = readVarint()
+                const arr: bigint[] = []
+                for (let i = 0; i < len; i++) arr.push(readVarint64())
+                result[field.name] = arr
+                break
+            }
+            default:
+                throw new Error(`Unknown type: ${field.type}`)
+        }
+    }
+
+    return result
+}

package/src/nft/buildImmutableData.ts

@@ -0,0 +1,321 @@
+import {Serializer} from '@wharfkit/antelope'
+import {getItem} from '../data/catalog'
+import {
+    getModuleCapabilityType,
+    MODULE_CRAFTER,
+    MODULE_ENGINE,
+    MODULE_GATHERER,
+    MODULE_GENERATOR,
+    MODULE_HAULER,
+    MODULE_LOADER,
+    MODULE_STORAGE,
+    MODULE_WARP,
+} from '../capabilities/modules'
+import {decodeStat, decodeCraftedItemStats} from '../derivation/crafting'
+import {getStatDefinitions} from '../derivation/stats'
+import type {ResourceCategory} from '../types'
+import {Types as ServerTypes} from '../contracts/server'
+import {
+    buildEntityDescription,
+    computeCrafterDrain,
+    computeCrafterSpeed,
+    computeEngineDrain,
+    computeEngineThrust,
+    computeGathererDepth,
+    computeGathererDrain,
+    computeGathererYield,
+    computeGeneratorCap,
+    computeGeneratorRech,
+    computeHaulerCapacity,
+    computeHaulerDrain,
+    computeHaulerEfficiency,
+    computeLoaderMass,
+    computeLoaderThrust,
+    computeWarpRange,
+} from './description'
+
+export type AtomicAttributeType =
+    | 'string'
+    | 'uint8'
+    | 'uint16'
+    | 'uint32'
+    | 'uint64'
+    | 'int32'
+    | 'image'
+    | 'ipfs'
+    | 'UINT16_VEC'
+    | 'UINT64_VEC'
+
+export interface ImmutableEntry {
+    first: string
+    second: [AtomicAttributeType, unknown]
+}
+
+export interface ImmutableModuleSlot {
+    type?: number | string | bigint
+    installed?: {item_id: number | string | bigint; stats: number | string | bigint}
+}
+
+export function moduleSlotsForImmutable(
+    modules: ServerTypes.module_entry[]
+): ImmutableModuleSlot[] {
+    return modules.map((m) => ({
+        type: Number(m.type.toString()),
+        installed: m.installed
+            ? {
+                  item_id: Number(m.installed.item_id.toString()),
+                  stats: BigInt(m.installed.stats.toString()),
+              }
+            : undefined,
+    }))
+}
+
+const IMAGE_HOST_URL = 'https://item.shiploadgame.com/item'
+
+function bytesToBase64Url(bytes: Uint8Array): string {
+    let binary = ''
+    for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]!)
+    const b64 = btoa(binary)
+    return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+export function computeNftImageUrl(
+    item: {item_id: number; stats: bigint; modules: ImmutableModuleSlot[]; quantity: number},
+    originX: number,
+    originY: number
+): string {
+    const payload = ServerTypes.nft_item_payload.from({
+        item: {
+            item_id: item.item_id,
+            stats: String(item.stats),
+            modules: item.modules,
+            quantity: item.quantity,
+        },
+        location: {x: String(originX), y: String(originY)},
+    })
+    const bytes = Serializer.encode({object: payload}).array
+    return `${IMAGE_HOST_URL}/${bytesToBase64Url(bytes)}.png`
+}
+
+function commonBaseImmutable(
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number,
+    img: string
+): ImmutableEntry[] {
+    return [
+        {first: 'quantity', second: ['uint32', quantity]},
+        {first: 'stats', second: ['uint64', String(stats)]},
+        {first: 'origin_x', second: ['int32', originX]},
+        {first: 'origin_y', second: ['int32', originY]},
+        {first: 'img', second: ['string', img]},
+        {first: 'deposit_amount', second: ['uint64', '0']},
+        {first: 'deposit_token', second: ['uint64', '0']},
+        {first: 'deposit_symbol', second: ['uint64', '0']},
+    ]
+}
+
+export function buildResourceImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number
+): ImmutableEntry[] {
+    const item = getItem(itemId)
+    const cat = item.category
+    if (!cat) throw new Error(`Resource item ${itemId} has no category`)
+    const definitions = getStatDefinitions(cat as ResourceCategory)
+    const img = computeNftImageUrl(
+        {item_id: itemId, stats, modules: [], quantity},
+        originX,
+        originY
+    )
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    base.push({first: definitions[0].key, second: ['uint16', decodeStat(stats, 0)]})
+    base.push({first: definitions[1].key, second: ['uint16', decodeStat(stats, 1)]})
+    base.push({first: definitions[2].key, second: ['uint16', decodeStat(stats, 2)]})
+    return base
+}
+
+export function buildComponentImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number
+): ImmutableEntry[] {
+    const img = computeNftImageUrl(
+        {item_id: itemId, stats, modules: [], quantity},
+        originX,
+        originY
+    )
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    const decoded = decodeCraftedItemStats(itemId, stats)
+    for (const [key, value] of Object.entries(decoded)) {
+        base.push({first: key, second: ['uint16', value]})
+    }
+    return base
+}
+
+export function buildModuleImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number
+): ImmutableEntry[] {
+    const img = computeNftImageUrl(
+        {item_id: itemId, stats, modules: [], quantity},
+        originX,
+        originY
+    )
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    const subtype = getModuleCapabilityType(itemId)
+    const item = getItem(itemId)
+    switch (subtype) {
+        case MODULE_ENGINE: {
+            const vol = decodeStat(stats, 0)
+            const thm = decodeStat(stats, 1)
+            base.push({first: 'volatility', second: ['uint16', vol]})
+            base.push({first: 'thermal', second: ['uint16', thm]})
+            base.push({first: 'thrust', second: ['uint32', computeEngineThrust(vol)]})
+            base.push({first: 'drain', second: ['uint16', computeEngineDrain(thm)]})
+            break
+        }
+        case MODULE_GENERATOR: {
+            const res = decodeStat(stats, 0)
+            const ref = decodeStat(stats, 1)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'capacity', second: ['uint16', computeGeneratorCap(res)]})
+            base.push({first: 'recharge', second: ['uint16', computeGeneratorRech(ref)]})
+            break
+        }
+        case MODULE_GATHERER: {
+            const str = decodeStat(stats, 0)
+            const tol = decodeStat(stats, 1)
+            const con = decodeStat(stats, 2)
+            const ref = decodeStat(stats, 3)
+            base.push({first: 'strength', second: ['uint16', str]})
+            base.push({first: 'tolerance', second: ['uint16', tol]})
+            base.push({first: 'conductivity', second: ['uint16', con]})
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
+            base.push({first: 'drain', second: ['uint16', computeGathererDrain(con)]})
+            base.push({first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)]})
+            break
+        }
+        case MODULE_LOADER: {
+            const fin = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'plasticity', second: ['uint16', pla]})
+            base.push({first: 'mass', second: ['uint32', computeLoaderMass(fin)]})
+            base.push({first: 'thrust', second: ['uint16', computeLoaderThrust(pla)]})
+            break
+        }
+        case MODULE_WARP: {
+            const res = decodeStat(stats, 0)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'range', second: ['uint32', computeWarpRange(res)]})
+            break
+        }
+        case MODULE_CRAFTER: {
+            const rea = decodeStat(stats, 0)
+            const fin = decodeStat(stats, 1)
+            base.push({first: 'reactivity', second: ['uint16', rea]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
+            base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(rea)]})
+            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(fin)]})
+            break
+        }
+        case MODULE_STORAGE: {
+            const str = decodeStat(stats, 0)
+            const den = decodeStat(stats, 1)
+            const hrd = decodeStat(stats, 2)
+            const com = decodeStat(stats, 3)
+            const sum = str + den + hrd + com
+            base.push({first: 'strength', second: ['uint16', str]})
+            base.push({first: 'density', second: ['uint16', den]})
+            base.push({first: 'hardness', second: ['uint16', hrd]})
+            base.push({first: 'cohesion', second: ['uint16', com]})
+            base.push({
+                first: 'capacity_bonus_pct',
+                second: ['uint16', 10 + Math.floor((sum * 10) / 2997)],
+            })
+            break
+        }
+        case MODULE_HAULER: {
+            const res = decodeStat(stats, 0)
+            const pla = decodeStat(stats, 1)
+            const ref = decodeStat(stats, 2)
+            base.push({first: 'resonance', second: ['uint16', res]})
+            base.push({first: 'plasticity', second: ['uint16', pla]})
+            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res)]})
+            base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(pla)]})
+            base.push({first: 'drain', second: ['uint16', computeHaulerDrain(ref)]})
+            break
+        }
+    }
+    return base
+}
+
+export function buildEntityImmutable(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number,
+    modules: ImmutableModuleSlot[]
+): ImmutableEntry[] {
+    const moduleItems: number[] = []
+    const moduleStats: string[] = []
+    for (const m of modules) {
+        if (m.installed) {
+            moduleItems.push(Number(m.installed.item_id))
+            moduleStats.push(String(m.installed.stats))
+        } else {
+            moduleItems.push(0)
+            moduleStats.push('0')
+        }
+    }
+    const img = computeNftImageUrl({item_id: itemId, stats, modules, quantity}, originX, originY)
+    const base = commonBaseImmutable(quantity, stats, originX, originY, img)
+    base.push({first: 'module_items', second: ['UINT16_VEC', moduleItems]})
+    base.push({first: 'module_stats', second: ['UINT64_VEC', moduleStats]})
+    const description = buildEntityDescription(
+        itemId,
+        stats,
+        moduleItems,
+        moduleStats.map((s) => BigInt(s))
+    )
+    base.push({first: 'description', second: ['string', description]})
+    return base
+}
+
+export function buildImmutableData(
+    itemId: number,
+    quantity: number,
+    stats: bigint,
+    originX: number,
+    originY: number,
+    modules: ImmutableModuleSlot[] = []
+): ImmutableEntry[] {
+    const item = getItem(itemId)
+    if (item.type === 'resource') {
+        return buildResourceImmutable(itemId, quantity, stats, originX, originY)
+    }
+    if (item.type === 'component') {
+        return buildComponentImmutable(itemId, quantity, stats, originX, originY)
+    }
+    if (item.type === 'module') {
+        return buildModuleImmutable(itemId, quantity, stats, originX, originY)
+    }
+    if (item.type === 'entity') {
+        return buildEntityImmutable(itemId, quantity, stats, originX, originY, modules)
+    }
+    throw new Error(`Unsupported item type for wrap: ${item.type}`)
+}