PHP WebShell

• .. (вверх)
• [DIR] ..
• [FILE] Arguments.ts
• [FILE] Commands.ts
• [FILE] Inputs.ts
• [FILE] ObjectCache.ts
• [FILE] Transaction.ts
• [FILE] TransactionData.ts
• [DIR] __tests__
• [DIR] data
• [DIR] executor
• [FILE] hash.ts
• [FILE] index.ts
• [DIR] intents
• [FILE] json-rpc-resolver.ts
• [FILE] object.ts
• [FILE] pure.ts
• [FILE] serializer.ts
• [FILE] utils.ts

Просмотр файла: pure.ts

// Copyright (c) Mysten Labs, Inc.
// Modifications Copyright (c) 2024 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

import { isSerializedBcs } from '@iota/bcs';
import type { BcsType, SerializedBcs } from '@iota/bcs';

import { bcs } from '../bcs/index.js';
import type { Argument } from './data/internal.js';

export function createPure<T>(makePure: (value: SerializedBcs<any, any> | Uint8Array) => T) {
    function pure<T extends PureTypeName>(
        type: T extends PureTypeName ? ValidPureTypeName<T> : T,
        value: ShapeFromPureTypeName<T>,
    ): T;

    function pure(
        /**
         * The pure value, serialized to BCS. If this is a Uint8Array, then the value
         * is assumed to be raw bytes, and will be used directly.
         */
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        value: SerializedBcs<any, any> | Uint8Array,
    ): T;

    function pure(
        typeOrSerializedValue?: PureTypeName | SerializedBcs<any, any> | Uint8Array,
        value?: unknown,
    ): T {
        if (typeof typeOrSerializedValue === 'string') {
            return makePure(schemaFromName(typeOrSerializedValue).serialize(value as never));
        }

        if (typeOrSerializedValue instanceof Uint8Array || isSerializedBcs(typeOrSerializedValue)) {
            return makePure(typeOrSerializedValue);
        }

        throw new Error('tx.pure must be called either a bcs type name, or a serialized bcs value');
    }

    pure.u8 = (value: number) => makePure(bcs.U8.serialize(value));
    pure.u16 = (value: number) => makePure(bcs.U16.serialize(value));
    pure.u32 = (value: number) => makePure(bcs.U32.serialize(value));
    pure.u64 = (value: bigint | number | string) => makePure(bcs.U64.serialize(value));
    pure.u128 = (value: bigint | number | string) => makePure(bcs.U128.serialize(value));
    pure.u256 = (value: bigint | number | string) => makePure(bcs.U256.serialize(value));
    pure.bool = (value: boolean) => makePure(bcs.Bool.serialize(value));
    pure.string = (value: string) => makePure(bcs.String.serialize(value));
    pure.address = (value: string) => makePure(bcs.Address.serialize(value));
    pure.id = pure.address;
    pure.vector = <Type extends PureTypeName>(
        type: T extends PureTypeName ? ValidPureTypeName<Type> : Type,
        value: Iterable<ShapeFromPureTypeName<Type>> & { length: number },
    ) => {
        return makePure(bcs.vector(schemaFromName(type as BasePureType)).serialize(value as never));
    };
    pure.option = <Type extends PureTypeName>(
        type: T extends PureTypeName ? ValidPureTypeName<Type> : Type,
        value: ShapeFromPureTypeName<Type> | null | undefined,
    ) => {
        return makePure(bcs.option(schemaFromName(type)).serialize(value as never));
    };

    return pure;
}

export type BasePureType =
    | 'u8'
    | 'u16'
    | 'u32'
    | 'u64'
    | 'u128'
    | 'u256'
    | 'bool'
    | 'id'
    | 'string'
    | 'address';

export type PureTypeName = BasePureType | `vector<${string}>` | `option<${string}>`;
export type ValidPureTypeName<T extends string> = T extends BasePureType
    ? PureTypeName
    : T extends `vector<${infer U}>`
      ? ValidPureTypeName<U>
      : T extends `option<${infer U}>`
        ? ValidPureTypeName<U>
        : PureTypeValidationError<T>;

type ShapeFromPureTypeName<T extends PureTypeName> = T extends BasePureType
    ? Parameters<ReturnType<typeof createPure<Argument>>[T]>[0]
    : T extends `vector<${infer U extends PureTypeName}>`
      ? ShapeFromPureTypeName<U>[]
      : T extends `option<${infer U extends PureTypeName}>`
        ? ShapeFromPureTypeName<U> | null
        : never;

type PureTypeValidationError<T extends string> = T & {
    error: `Invalid Pure type name: ${T}`;
};

function schemaFromName<T extends PureTypeName>(
    name: T extends PureTypeName ? ValidPureTypeName<T> : T,
): BcsType<ShapeFromPureTypeName<T>> {
    switch (name) {
        case 'u8':
            return bcs.u8() as never;
        case 'u16':
            return bcs.u16() as never;
        case 'u32':
            return bcs.u32() as never;
        case 'u64':
            return bcs.u64() as never;
        case 'u128':
            return bcs.u128() as never;
        case 'u256':
            return bcs.u256() as never;
        case 'bool':
            return bcs.bool() as never;
        case 'string':
            return bcs.string() as never;
        case 'id':
        case 'address':
            return bcs.Address as never;
    }

    const generic = name.match(/^(vector|option)<(.+)>$/);
    if (generic) {
        const [kind, inner] = generic.slice(1);
        if (kind === 'vector') {
            return bcs.vector(schemaFromName(inner as PureTypeName)) as never;
        } else {
            return bcs.option(schemaFromName(inner as PureTypeName)) as never;
        }
    }

    throw new Error(`Invalid Pure type name: ${name}`);
}

Выполнить команду