Use internal asset account (#76)

* Use internal asset account

* Fix lint

* Separate delegate type fields

Author: febo

clients/js/asset/src/extensions/index.ts

@@ -1,6 +1,6 @@
 import { Serializer } from '@metaplex-foundation/umi/serializers';
+import { Asset } from '..';
 import {
-  Asset,
   Attributes,
   Blob,
   Bucket,

clients/js/asset/src/extensions/properties.ts

@@ -8,7 +8,8 @@ import {
   u8,
 } from '@metaplex-foundation/umi/serializers';
 import { TypedExtension, getExtension } from '.';
-import { Asset, ExtensionType, Type, getTypeSerializer } from '../generated';
+import { Asset } from '..';
+import { ExtensionType, Type, getTypeSerializer } from '../generated';
 
 type Property =
   | Omit<Text, 'type'>

clients/js/asset/src/generated/accounts/index.ts

@@ -25,14 +25,13 @@ import {
   string,
 } from '@metaplex-foundation/umi/serializers';
 import {
-  AssetAccountData,
+  InternalAssetAccountData,
   NullablePublicKeyArgs,
-  getAssetAccountDataSerializer,
+  getInternalAssetAccountDataSerializer,
   getNullablePublicKeySerializer,
 } from '../../hooked';
 import {
   DelegateArgs,
-  Discriminator,
   DiscriminatorArgs,
   StandardArgs,
   StateArgs,
@@ -42,67 +41,76 @@ import {
   getStateSerializer,
 } from '../types';
 
-export type Asset = Account<AssetAccountData>;
+export type InternalAsset = Account<InternalAssetAccountData>;
 
-export function deserializeAsset(rawAccount: RpcAccount): Asset {
-  return deserializeAccount(rawAccount, getAssetAccountDataSerializer());
+export function deserializeInternalAsset(
+  rawAccount: RpcAccount
+): InternalAsset {
+  return deserializeAccount(
+    rawAccount,
+    getInternalAssetAccountDataSerializer()
+  );
 }
 
-export async function fetchAsset(
+export async function fetchInternalAsset(
   context: Pick<Context, 'rpc'>,
   publicKey: PublicKey | Pda,
   options?: RpcGetAccountOptions
-): Promise<Asset> {
+): Promise<InternalAsset> {
   const maybeAccount = await context.rpc.getAccount(
     toPublicKey(publicKey, false),
     options
   );
-  assertAccountExists(maybeAccount, 'Asset');
-  return deserializeAsset(maybeAccount);
+  assertAccountExists(maybeAccount, 'InternalAsset');
+  return deserializeInternalAsset(maybeAccount);
 }
 
-export async function safeFetchAsset(
+export async function safeFetchInternalAsset(
   context: Pick<Context, 'rpc'>,
   publicKey: PublicKey | Pda,
   options?: RpcGetAccountOptions
-): Promise<Asset | null> {
+): Promise<InternalAsset | null> {
   const maybeAccount = await context.rpc.getAccount(
     toPublicKey(publicKey, false),
     options
   );
-  return maybeAccount.exists ? deserializeAsset(maybeAccount) : null;
+  return maybeAccount.exists ? deserializeInternalAsset(maybeAccount) : null;
 }
 
-export async function fetchAllAsset(
+export async function fetchAllInternalAsset(
   context: Pick<Context, 'rpc'>,
   publicKeys: Array<PublicKey | Pda>,
   options?: RpcGetAccountsOptions
-): Promise<Asset[]> {
+): Promise<InternalAsset[]> {
   const maybeAccounts = await context.rpc.getAccounts(
     publicKeys.map((key) => toPublicKey(key, false)),
     options
   );
   return maybeAccounts.map((maybeAccount) => {
-    assertAccountExists(maybeAccount, 'Asset');
-    return deserializeAsset(maybeAccount);
+    assertAccountExists(maybeAccount, 'InternalAsset');
+    return deserializeInternalAsset(maybeAccount);
   });
 }
 
-export async function safeFetchAllAsset(
+export async function safeFetchAllInternalAsset(
   context: Pick<Context, 'rpc'>,
   publicKeys: Array<PublicKey | Pda>,
   options?: RpcGetAccountsOptions
-): Promise<Asset[]> {
+): Promise<InternalAsset[]> {
   const maybeAccounts = await context.rpc.getAccounts(
     publicKeys.map((key) => toPublicKey(key, false)),
     options
   );
   return maybeAccounts
     .filter((maybeAccount) => maybeAccount.exists)
-    .map((maybeAccount) => deserializeAsset(maybeAccount as RpcAccount));
+    .map((maybeAccount) =>
+      deserializeInternalAsset(maybeAccount as RpcAccount)
+    );
 }
 
-export function getAssetGpaBuilder(context: Pick<Context, 'rpc' | 'programs'>) {
+export function getInternalAssetGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
   const programId = context.programs.getPublicKey(
     'asset',
     'AssetGtQBTSgm5s91d1RAQod5JmaZiJDxqsgtqrZud73'
@@ -129,6 +137,7 @@ export function getAssetGpaBuilder(context: Pick<Context, 'rpc' | 'programs'>) {
       delegate: [null, getDelegateSerializer()],
       name: [null, string({ size: 35 })],
     })
-    .deserializeUsing<Asset>((account) => deserializeAsset(account))
-    .whereField('discriminator', Discriminator.Asset);
+    .deserializeUsing<InternalAsset>((account) =>
+      deserializeInternalAsset(account)
+    );
 }

clients/js/asset/src/generated/accounts/asset.ts renamed to clients/js/asset/src/generated/accounts/internalAsset.ts

@@ -6,7 +6,6 @@
  * @see https://github.com/metaplex-foundation/kinobi
  */
 
-export * from './accounts';
 export * from './errors';
 export * from './instructions';
 export * from './programs';

clients/js/asset/src/generated/index.ts

@@ -10,7 +10,6 @@ import { PublicKey } from '@metaplex-foundation/umi';
 import {
   Serializer,
   bool,
-  mapSerializer,
   publicKey as publicKeySerializer,
   string,
   struct,
@@ -19,6 +18,7 @@ import {
   Delegate,
   DelegateArgs,
   Discriminator,
+  DiscriminatorArgs,
   Standard,
   StandardArgs,
   State,
@@ -34,7 +34,7 @@ import {
   getNullablePublicKeySerializer,
 } from '../../hooked';
 
-export type AssetAccountData = {
+export type InternalAssetAccountData = {
   discriminator: Discriminator;
   state: State;
   standard: Standard;
@@ -46,7 +46,8 @@ export type AssetAccountData = {
   name: string;
 };
 
-export type AssetAccountDataArgs = {
+export type InternalAssetAccountDataArgs = {
+  discriminator: DiscriminatorArgs;
   state: StateArgs;
   standard: StandardArgs;
   mutable: boolean;
@@ -57,25 +58,22 @@ export type AssetAccountDataArgs = {
   name: string;
 };
 
-export function getAssetAccountDataSerializer(): Serializer<
-  AssetAccountDataArgs,
-  AssetAccountData
+export function getInternalAssetAccountDataSerializer(): Serializer<
+  InternalAssetAccountDataArgs,
+  InternalAssetAccountData
 > {
-  return mapSerializer<AssetAccountDataArgs, any, AssetAccountData>(
-    struct<AssetAccountData>(
-      [
-        ['discriminator', getDiscriminatorSerializer()],
-        ['state', getStateSerializer()],
-        ['standard', getStandardSerializer()],
-        ['mutable', bool()],
-        ['owner', publicKeySerializer()],
-        ['group', getNullablePublicKeySerializer()],
-        ['authority', publicKeySerializer()],
-        ['delegate', getDelegateSerializer()],
-        ['name', string({ size: 35 })],
-      ],
-      { description: 'AssetAccountData' }
-    ),
-    (value) => ({ ...value, discriminator: Discriminator.Asset })
-  ) as Serializer<AssetAccountDataArgs, AssetAccountData>;
+  return struct<InternalAssetAccountData>(
+    [
+      ['discriminator', getDiscriminatorSerializer()],
+      ['state', getStateSerializer()],
+      ['standard', getStandardSerializer()],
+      ['mutable', bool()],
+      ['owner', publicKeySerializer()],
+      ['group', getNullablePublicKeySerializer()],
+      ['authority', publicKeySerializer()],
+      ['delegate', getDelegateSerializer()],
+      ['name', string({ size: 35 })],
+    ],
+    { description: 'InternalAssetAccountData' }
+  ) as Serializer<InternalAssetAccountDataArgs, InternalAssetAccountData>;
 }

clients/js/asset/src/generated/types/assetAccountData.ts renamed to clients/js/asset/src/generated/types/internalAssetAccountData.ts

@@ -1,3 +1,3 @@
-export * from './assetAccountData';
+export * from './internalAssetAccountData';
 export * from './delegateRoles';
 export * from './nullablePublicKey';

clients/js/asset/src/hooked/index.ts

@@ -7,39 +7,45 @@ import {
   ExtensionType,
 } from '../generated';
 import {
-  AssetAccountData as BaseAssetAccountData,
-  AssetAccountDataArgs as BaseAssetAccountDataArgs,
-  getAssetAccountDataSerializer as getBaseAssetAccountDataSerializer,
-} from '../generated/types/assetAccountData';
+  InternalAssetAccountData as BaseInternalAssetAccountData,
+  InternalAssetAccountDataArgs as BaseInternalAssetAccountDataArgs,
+  getInternalAssetAccountDataSerializer as getBaseInternalAssetAccountDataSerializer,
+} from '../generated/types/internalAssetAccountData';
 import { getExtensionHeaderSerializer } from '../generated/types/extensionHeader';
 
-export type AssetAccountData = Omit<BaseAssetAccountData, 'delegate'> & {
+export type InternalAssetAccountData = Omit<
+  BaseInternalAssetAccountData,
+  'delegate'
+> & {
   delegate: (Omit<Delegate, 'roles'> & { roles: DelegateRole[] }) | null;
   extensions: TypedExtension[];
 };
 
-export type AssetAccountDataArgs = Omit<
-  BaseAssetAccountDataArgs,
+export type InternalAssetAccountDataArgs = Omit<
+  BaseInternalAssetAccountDataArgs,
   'delegate'
 > & {
   delegate: (Omit<Delegate, 'roles'> & { roles: DelegateRole[] }) | null;
   extensions: TypedExtension[];
 };
 
-export const getAssetAccountDataSerializer = (): Serializer<
-  AssetAccountDataArgs,
-  AssetAccountData
+export const getInternalAssetAccountDataSerializer = (): Serializer<
+  InternalAssetAccountDataArgs,
+  InternalAssetAccountData
 > => ({
   description: 'AssetAccountData',
   fixedSize: null,
   maxSize: null,
   serialize: () => {
     throw new Error('Operation not supported.');
   },
-  deserialize: (buffer: Uint8Array, offset = 0): [AssetAccountData, number] => {
+  deserialize: (
+    buffer: Uint8Array,
+    offset = 0
+  ): [InternalAssetAccountData, number] => {
     // Account.
     const [asset, assetOffset] =
-      getBaseAssetAccountDataSerializer().deserialize(buffer, offset);
+      getBaseInternalAssetAccountDataSerializer().deserialize(buffer, offset);
     if (asset.discriminator !== Discriminator.Asset) {
       throw new Error(
         `Expected an Asset account, got account discriminator: ${asset.discriminator}`

clients/js/asset/src/hooked/assetAccountData.ts renamed to clients/js/asset/src/hooked/internalAssetAccountData.ts

@@ -1,4 +1,32 @@
-import { publicKey } from '@metaplex-foundation/umi';
+import {
+  Context,
+  PublicKey,
+  gpaBuilder,
+  publicKey,
+} from '@metaplex-foundation/umi';
+import {
+  bool,
+  publicKey as publicKeySerializer,
+  string,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  DiscriminatorArgs,
+  StandardArgs,
+  StateArgs,
+  getDiscriminatorSerializer,
+  getStandardSerializer,
+  getStateSerializer,
+} from './generated';
+import {
+  InternalAsset as Asset,
+  deserializeInternalAsset as deserializeAsset,
+} from './generated/accounts/internalAsset';
+import {
+  DelegateRolesArgs,
+  NullablePublicKeyArgs,
+  getDelegateRolesSerializer,
+  getNullablePublicKeySerializer,
+} from './hooked';
 
 export * from './allocate';
 export * from './approve';
@@ -26,4 +54,45 @@ export * from './updateWithBuffer';
 export * from './verify';
 export * from './write';
 
+export {
+  InternalAsset as Asset,
+  deserializeInternalAsset as deserializeAsset,
+  fetchAllInternalAsset as fetchAllAsset,
+  fetchInternalAsset as fetchAsset,
+  safeFetchAllInternalAsset as safeFetchAllAsset,
+  safeFetchInternalAsset as safeFetchAsset,
+} from './generated/accounts/internalAsset';
+
 export const SYSTEM_PROGRAM_ID = publicKey('11111111111111111111111111111111');
+
+export function getAssetGpaBuilder(context: Pick<Context, 'rpc' | 'programs'>) {
+  const programId = context.programs.getPublicKey(
+    'asset',
+    'AssetGtQBTSgm5s91d1RAQod5JmaZiJDxqsgtqrZud73'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: DiscriminatorArgs;
+      state: StateArgs;
+      standard: StandardArgs;
+      mutable: boolean;
+      owner: PublicKey;
+      group: NullablePublicKeyArgs;
+      authority: PublicKey;
+      delegate: NullablePublicKeyArgs;
+      roles: DelegateRolesArgs;
+      name: string;
+    }>({
+      discriminator: [0, getDiscriminatorSerializer()],
+      state: [1, getStateSerializer()],
+      standard: [2, getStandardSerializer()],
+      mutable: [3, bool()],
+      owner: [4, publicKeySerializer()],
+      group: [36, getNullablePublicKeySerializer()],
+      authority: [68, publicKeySerializer()],
+      delegate: [100, getNullablePublicKeySerializer()],
+      roles: [132, getDelegateRolesSerializer()],
+      name: [133, string({ size: 35 })],
+    })
+    .deserializeUsing<Asset>((account) => deserializeAsset(account));
+}