@velas/account-agent/src/helper/instructions.js

sdk

import BN from 'bn.js';
import { Enum, Assignable, SCHEMA } from './solana-borsh';

export class Initialize        extends Assignable {}
export class AddOwner          extends Assignable {}
export class ReplaceOwner      extends Assignable {}
export class AddOperational    extends Assignable {}
export class AddProgram        extends Assignable {}
export class Execute           extends Assignable {}
export class RemoveOperational extends Assignable {}
export class RemoveProgramPermission extends Assignable {}
export class Owner             extends Assignable {}
export class Operational       extends Assignable {}
export class RequestedOpt      extends Assignable {};
export class Transfer          extends Assignable {}
export class WhitelistPrograms    extends Assignable {}
export class WhitelistTokens      extends Assignable {}
export class OperationalPublicKey extends Assignable {}
export class Append               extends Assignable {}
export class Insert               extends Assignable {}
export class ExtendOperational    extends Assignable {}
export class MergeOperational     extends Assignable {}
export class SponsorAndExecute     extends Assignable {};

export class StorageOperation extends Enum {
    static append() {
      return new StorageOperation({ append: new Append({}) });
    };
  
    static insert() {
      return new StorageOperation({ insert: new Insert({}) });
    };
};

export class SignerType extends Enum {
    static owner() {
        return new SignerType({ owner: new Owner({}) });
    };
  
    static operational(signerIndex) {
        return new SignerType({ operational: new Operational({ signerIndex }) });
    };
};

export class SolidInstruction extends Enum {
    static initialize() {
        return new SolidInstruction({ initialize: new Initialize({}) });
    };

    static addOwner() {
        return new SolidInstruction({ addOwner: new AddOwner({}) });
    };

    static replaceOwner() {
        return new SolidInstruction({ replaceOwner: new ReplaceOwner({}) });
    };

    static transfer({ amount, signerType }) {
        return new SolidInstruction({ 
            transfer: new Transfer({ 
                amount: new BN(amount),
                signerType,
            })
        });
    };

    static execute(params) {
        return new SolidInstruction({ execute: new Execute({
            programIndex: params.programIndex,
            signerType:   params.signerType,
            executeData:  params.executeData,
        }) });
    };

    static sponsorAndExecute(params) {
        return new SolidInstruction({ sponsorAndExecute: new SponsorAndExecute({
            signerType:   params.signerType,
            executeData:  params.executeData,
            estimatedGas: new BN(params.estimatedGas),
        }) });
    };

    static addOperational(params) {
        return new SolidInstruction({ 
            addOperational: new AddOperational({
                requestedOption: params.requestedOption, 
                signerType:      params.signerType,
            })
        });
    };

    static addProgram(params) {        
        return new SolidInstruction({ 
            addProgram: new AddProgram({
                storageOperation: StorageOperation.append(),
                signerType:  params.signerType,
            })
        });
    };

    static removeOperational({ operational2RemoveIndex, signerType}) {
        return new SolidInstruction({ removeOperational: new RemoveOperational({
            operational2RemoveIndex, 
            signerType,
        }) });
    };

    static removeProgramPermission({ operational2RemoveIndex, signerType, program2RemoveIndex}) {
        return new SolidInstruction({ removeProgramPermission: new RemoveProgramPermission({
            operational2RemoveIndex,
            signerType,
            program2RemoveIndex,
        }) });
    };

    static extendOperational(params) {
        return new SolidInstruction({ 
            extendOperational: new ExtendOperational({ 
                operationalToExtendIndex: params.operationalToExtendIndex,
                requestedOption: params.requestedOption,
                signerType: params.signerType,
        }) });
    };

    static mergeOperational(operationalMergeWithIndex, operationalMergeToIndex, signerType){
        return new SolidInstruction({
            mergeOperational: new MergeOperational({
                operationalMergeWithIndex,
                operationalMergeToIndex,
                signerType
            })
        });
    }
};

export class VPublicKey extends Assignable {
    static fromBuffer(publicKey) {
        return new VPublicKey({ bytes: Uint8Array.from(publicKey.toBuffer()) });
    };
};

SCHEMA.set(SolidInstruction, {
    kind: 'enum',
    field: 'enum',
    values: [
        ['initialize',        Initialize],
        ['addOwner',          AddOwner],
        ['addOperational',    AddOperational],
        ['extendOperational', ExtendOperational],
        ['mergeOperational',  MergeOperational],
        ['replaceOwner',      ReplaceOwner],
        ['skip_6',            Initialize],
        ['removeOperational', RemoveOperational],
        ['skip_8',            Initialize],
        ['skip_9',            Initialize],
        ['execute',           Execute],
        ['transfer',          Transfer],
        ['skip_12',           Initialize],
        ['skip_13',           Initialize],
        ['skip_14',           Initialize],
        ['skip_15',           Initialize],
        ['skip_16',           Initialize],
        ['skip_17',           Initialize],
        ['addProgram',        AddProgram],
        ['removeProgramPermission', RemoveProgramPermission],
        ['sponsorAndExecute', SponsorAndExecute],
    ],
});

SCHEMA.set(MergeOperational, {
    kind: 'struct',
    fields: [
        ['operationalMergeWithIndex', 'u8'],
        ['operationalMergeToIndex', 'u8'],
        ['signerType', SignerType],
    ]
});

SCHEMA.set(RequestedOpt, {
    kind: 'struct', 
    fields: [
        ['agentType',                ['u8']],
        ['scopes',                   ['u8']],
        ['whitelistProgramsIndexes', ['u8']],
        ['whitelistTokensIndices',   ['u8']],
        ['isMasterKey',               'u8'],
    ],
});

SCHEMA.set(Initialize,        { kind: 'struct', fields: [] });
SCHEMA.set(AddOwner,          { kind: 'struct', fields: [] });
SCHEMA.set(ReplaceOwner,      { kind: 'struct', fields: [] });
SCHEMA.set(RemoveOperational, { 
    kind: 'struct', 
    fields: [
      ['operational2RemoveIndex', 'u8'],
      ['signerType', SignerType],
    ] 
  });

SCHEMA.set(AddOperational, { 
    kind: 'struct', 
    fields: [
        ['requestedOption', RequestedOpt],
        ['signerType',      SignerType],
    ],
});

SCHEMA.set(Transfer, { 
    kind: 'struct', 
    fields: [
        ['amount',     'u64'],
        ['signerType',  SignerType],
    ],
});

SCHEMA.set(AddProgram, { 
    kind: 'struct', 
    fields: [
        ['storageOperation', StorageOperation],
        ['signerType', SignerType],
    ],
});
  
SCHEMA.set(Execute, { 
    kind: 'struct', 
    fields: [
        ['programIndex', 'u8'],
        ['signerType', SignerType],
        ['executeData', ['u8']],
    ],
});

SCHEMA.set(SponsorAndExecute, { 
    kind: 'struct',
    fields: [
      ['signerType', SignerType],
      ['executeData', ['u8']],
      ['estimatedGas', 'u64']
    ] 
});

SCHEMA.set(VPublicKey, {
    kind: 'struct',
    fields: [['bytes', [32]]],
});

SCHEMA.set(Owner, { kind: 'struct', fields: [] });
SCHEMA.set(Operational, { 
    kind: 'struct', 
    fields: [
        ['signerIndex', 'u8']
    ] 
});

SCHEMA.set(Append, { kind: 'struct', fields: [] });
SCHEMA.set(Insert, { kind: 'struct', fields: [] });
SCHEMA.set(StorageOperation, {
  kind: 'enum',
  field: 'enum',
  values: [
    ['append', Append],
    ['insert', Insert],
  ],
});

SCHEMA.set(WhitelistPrograms, {
    kind: 'struct',
    fields: [
        ['pubkey', VPublicKey],
    ],
});

SCHEMA.set(WhitelistTokens, {
    kind: 'struct',
    fields: [
        ['pubkey', VPublicKey],
        ['daily_limit', 'u64'],
    ],
});

SCHEMA.set(SignerType, {
    kind:  'enum',
    field: 'enum',
    values: [
        ['owner',       Owner],
        ['operational', Operational],
    ],
});
  
SCHEMA.set(ExtendOperational, { 
    kind: 'struct', 
    fields: [
        ['operationalToExtendIndex', 'u8'],
        ['requestedOption',           RequestedOpt],
        ['signerType',                SignerType],
    ] 
});

SCHEMA.set(RemoveProgramPermission, { 
    kind: 'struct', 
    fields: [
        ['operational2RemoveIndex', 'u8'],
        ['program2RemoveIndex',     'u8'],
        ['signerType',               SignerType],
    ] 
});