From c53be57733478d0914e98fb4e9c1ac4683b3ea8a Mon Sep 17 00:00:00 2001 From: minahttpz Date: Tue, 31 Dec 2024 17:50:48 +0800 Subject: [PATCH 1/4] httpz token register --- .../icon.png | Bin 0 -> 4263 bytes .../source/FungibleToken.ts | 323 ++++++++++++++++++ .../source/HttpzTokenAdmin.ts | 106 ++++++ .../token.json | 9 + 4 files changed, 438 insertions(+) create mode 100755 token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/icon.png create mode 100755 token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/source/FungibleToken.ts create mode 100755 token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/source/HttpzTokenAdmin.ts create mode 100755 token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json diff --git a/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/icon.png b/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/icon.png new file mode 100755 index 0000000000000000000000000000000000000000..408d85713c4df8324503e5cff7e35826fda9a84f GIT binary patch literal 4263 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 { + /** The token symbol. */ + symbol: string; + /** A source code reference, which is placed within the `zkappUri` of the contract account. + * Typically a link to a file on github. */ + src: string; + /** Setting this to `true` will allow changing the verification key later with a signature from the deployer. This will allow updating the token contract at a later stage, for instance to react to an update of the o1js library. + * Setting it to `false` will make changes to the contract impossible, unless there is a backward incompatible change to the protocol. (see https://docs.minaprotocol.com/zkapps/writing-a-zkapp/feature-overview/permissions#example-impossible-to-upgrade and https://minafoundation.github.io/mina-fungible-token/deploy.html) */ + allowUpdates: boolean; +} + +export const FungibleTokenErrors = { + noAdminKey: "could not fetch admin contract key", + noPermissionToChangeAdmin: "Not allowed to change admin contract", + tokenPaused: "Token is currently paused", + noPermissionToMint: "Not allowed to mint tokens", + noPermissionToPause: "Not allowed to pause token", + noPermissionToResume: "Not allowed to resume token", + noTransferFromCirculation: "Can't transfer to/from the circulation account", + noPermissionChangeAllowed: + "Can't change permissions for access or receive on token accounts", + flashMinting: + "Flash-minting or unbalanced transaction detected. Please make sure that your transaction is balanced, and that your `AccountUpdate`s are ordered properly, so that tokens are not received before they are sent.", + unbalancedTransaction: "Transaction is unbalanced", +}; + +export class FungibleToken extends TokenContract { + @state(UInt8) + decimals = State(); + @state(PublicKey) + admin = State(); + @state(Bool) + paused = State(); + + // This defines the type of the contract that is used to control access to administrative actions. + // If you want to have a custom contract, overwrite this by setting FungibleToken.AdminContract to + // your own implementation of FungibleTokenAdminBase. + static AdminContract: new (...args: any) => FungibleTokenAdminBase = + HttpzTokenAdmin; + + readonly events = { + SetAdmin: SetAdminEvent, + Pause: PauseEvent, + Mint: MintEvent, + Burn: BurnEvent, + BalanceChange: BalanceChangeEvent, + }; + + async deploy(props: FungibleTokenDeployProps) { + await super.deploy(props); + this.paused.set(Bool(true)); + this.account.zkappUri.set(props.src); + this.account.tokenSymbol.set(props.symbol); + + this.account.permissions.set({ + ...Permissions.default(), + setVerificationKey: props.allowUpdates + ? Permissions.VerificationKey.proofDuringCurrentVersion() + : Permissions.VerificationKey.impossibleDuringCurrentVersion(), + setPermissions: Permissions.impossible(), + access: Permissions.proof(), + }); + } + + /** Update the verification key. + * This will only work when `allowUpdates` has been set to `true` during deployment. + */ + @method + async updateVerificationKey(vk: VerificationKey) { + const adminContract = await this.getAdminContract(); + const canChangeVerificationKey = + await adminContract.canChangeVerificationKey(vk); + canChangeVerificationKey.assertTrue( + FungibleTokenErrors.noPermissionToChangeAdmin + ); + this.account.verificationKey.set(vk); + } + + /** Initializes the account for tracking total circulation. + * @argument {PublicKey} admin - public key where the admin contract is deployed + * @argument {UInt8} decimals - number of decimals for the token + * @argument {Bool} startPaused - if set to `Bool(true), the contract will start in a mode where token minting and transfers are paused. This should be used for non-atomic deployments + */ + @method + async initialize(admin: PublicKey, decimals: UInt8, startPaused: Bool) { + this.account.provedState.requireEquals(Bool(false)); + + this.admin.set(admin); + this.decimals.set(decimals); + this.paused.set(Bool(false)); + + this.paused.set(startPaused); + + const accountUpdate = AccountUpdate.createSigned( + this.address, + this.deriveTokenId() + ); + let permissions = Permissions.default(); + // This is necessary in order to allow token holders to burn. + permissions.send = Permissions.none(); + permissions.setPermissions = Permissions.impossible(); + accountUpdate.account.permissions.set(permissions); + } + + public async getAdminContract(): Promise { + const admin = await Provable.witnessAsync(PublicKey, async () => { + let pk = await this.admin.fetch(); + assert(pk !== undefined, FungibleTokenErrors.noAdminKey); + return pk; + }); + this.admin.requireEquals(admin); + return new FungibleToken.AdminContract(admin); + } + + @method + async setAdmin(admin: PublicKey) { + const adminContract = await this.getAdminContract(); + const canChangeAdmin = await adminContract.canChangeAdmin(admin); + canChangeAdmin.assertTrue(FungibleTokenErrors.noPermissionToChangeAdmin); + this.admin.set(admin); + this.emitEvent("SetAdmin", new SetAdminEvent({ adminKey: admin })); + } + + @method.returns(AccountUpdate) + async mint(recipient: PublicKey, amount: UInt64): Promise { + this.paused + .getAndRequireEquals() + .assertFalse(FungibleTokenErrors.tokenPaused); + const accountUpdate = this.internal.mint({ address: recipient, amount }); + const adminContract = await this.getAdminContract(); + const canMint = await adminContract.canMint(accountUpdate); + canMint.assertTrue(FungibleTokenErrors.noPermissionToMint); + recipient + .equals(this.address) + .assertFalse(FungibleTokenErrors.noTransferFromCirculation); + this.approve(accountUpdate); + this.emitEvent("Mint", new MintEvent({ recipient, amount })); + const circulationUpdate = AccountUpdate.create( + this.address, + this.deriveTokenId() + ); + circulationUpdate.balanceChange = Int64.fromUnsigned(amount); + return accountUpdate; + } + + @method.returns(AccountUpdate) + async burn(from: PublicKey, amount: UInt64): Promise { + this.paused + .getAndRequireEquals() + .assertFalse(FungibleTokenErrors.tokenPaused); + const accountUpdate = this.internal.burn({ address: from, amount }); + const circulationUpdate = AccountUpdate.create( + this.address, + this.deriveTokenId() + ); + from + .equals(this.address) + .assertFalse(FungibleTokenErrors.noTransferFromCirculation); + circulationUpdate.balanceChange = Int64.fromUnsigned(amount).neg(); + this.emitEvent("Burn", new BurnEvent({ from, amount })); + return accountUpdate; + } + + @method + async pause() { + const adminContract = await this.getAdminContract(); + const canPause = await adminContract.canPause(); + canPause.assertTrue(FungibleTokenErrors.noPermissionToPause); + this.paused.set(Bool(true)); + this.emitEvent("Pause", new PauseEvent({ isPaused: Bool(true) })); + } + + @method + async resume() { + const adminContract = await this.getAdminContract(); + const canResume = await adminContract.canResume(); + canResume.assertTrue(FungibleTokenErrors.noPermissionToResume); + this.paused.set(Bool(false)); + this.emitEvent("Pause", new PauseEvent({ isPaused: Bool(false) })); + } + + @method + async transfer(from: PublicKey, to: PublicKey, amount: UInt64) { + this.paused + .getAndRequireEquals() + .assertFalse(FungibleTokenErrors.tokenPaused); + from + .equals(this.address) + .assertFalse(FungibleTokenErrors.noTransferFromCirculation); + to.equals(this.address).assertFalse( + FungibleTokenErrors.noTransferFromCirculation + ); + this.internal.send({ from, to, amount }); + } + + private checkPermissionsUpdate(update: AccountUpdate) { + let permissions = update.update.permissions; + + let { access, receive } = permissions.value; + let accessIsNone = Provable.equal( + Types.AuthRequired, + access, + Permissions.none() + ); + let receiveIsNone = Provable.equal( + Types.AuthRequired, + receive, + Permissions.none() + ); + let updateAllowed = accessIsNone.and(receiveIsNone); + + assert( + updateAllowed.or(permissions.isSome.not()), + FungibleTokenErrors.noPermissionChangeAllowed + ); + } + + /** Approve `AccountUpdate`s that have been created outside of the token contract. + * + * @argument {AccountUpdateForest} updates - The `AccountUpdate`s to approve. Note that the forest size is limited by the base token contract, @see TokenContract.MAX_ACCOUNT_UPDATES The current limit is 9. + */ + @method + async approveBase(updates: AccountUpdateForest): Promise { + this.paused + .getAndRequireEquals() + .assertFalse(FungibleTokenErrors.tokenPaused); + let totalBalance = Int64.from(0); + this.forEachUpdate(updates, (update, usesToken) => { + // Make sure that the account permissions are not changed + this.checkPermissionsUpdate(update); + this.emitEventIf( + usesToken, + "BalanceChange", + new BalanceChangeEvent({ + address: update.publicKey, + amount: update.balanceChange, + }) + ); + // Don't allow transfers to/from the account that's tracking circulation + update.publicKey + .equals(this.address) + .and(usesToken) + .assertFalse(FungibleTokenErrors.noTransferFromCirculation); + totalBalance = Provable.if( + usesToken, + totalBalance.add(update.balanceChange), + totalBalance + ); + totalBalance.isPositive().assertFalse(FungibleTokenErrors.flashMinting); + }); + totalBalance.assertEquals( + Int64.zero, + FungibleTokenErrors.unbalancedTransaction + ); + } + + @method.returns(UInt64) + async getBalanceOf(address: PublicKey): Promise { + const account = AccountUpdate.create(address, this.deriveTokenId()).account; + const balance = account.balance.get(); + account.balance.requireEquals(balance); + return balance; + } + + /** Reports the current circulating supply + * This does take into account currently unreduced actions. + */ + async getCirculating(): Promise { + let circulating = await this.getBalanceOf(this.address); + return circulating; + } + + @method.returns(UInt8) + async getDecimals(): Promise { + return this.decimals.getAndRequireEquals(); + } +} + +export class SetAdminEvent extends Struct({ + adminKey: PublicKey, +}) {} + +export class PauseEvent extends Struct({ + isPaused: Bool, +}) {} + +export class MintEvent extends Struct({ + recipient: PublicKey, + amount: UInt64, +}) {} + +export class BurnEvent extends Struct({ + from: PublicKey, + amount: UInt64, +}) {} + +export class BalanceChangeEvent extends Struct({ + address: PublicKey, + amount: Int64, +}) {} diff --git a/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/source/HttpzTokenAdmin.ts b/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/source/HttpzTokenAdmin.ts new file mode 100755 index 0000000..9d4fa68 --- /dev/null +++ b/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/source/HttpzTokenAdmin.ts @@ -0,0 +1,106 @@ +import { + AccountUpdate, + assert, + Bool, + method, + Provable, + PublicKey, + SmartContract, + State, + state, + UInt64, + Permissions, + VerificationKey, + DeployArgs, +} from "o1js"; +import { CIRCULATION_MAX } from "./constants.js"; + +export type FungibleTokenAdminBase = SmartContract & { + canMint(accountUpdate: AccountUpdate): Promise; + canChangeAdmin(admin: PublicKey): Promise; + canPause(): Promise; + canResume(): Promise; + canChangeVerificationKey(vk: VerificationKey): Promise; +}; + +export interface FungibleTokenAdminDeployProps + extends Exclude { + adminPublicKey: PublicKey; +} + +export class HttpzTokenAdmin + extends SmartContract + implements FungibleTokenAdminBase +{ + @state(PublicKey) + private adminPublicKey = State(); + + // Total mint amount + @state(UInt64) + private totalMintAmount = State(); + + async deploy(props: FungibleTokenAdminDeployProps) { + await super.deploy(props); + this.adminPublicKey.set(props.adminPublicKey); + this.totalMintAmount.set(UInt64.from(0)); + + this.account.permissions.set({ + ...Permissions.default(), + }); + } + + /** Update the verification key. + * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update. + */ + @method + public async updateVerificationKey(vk: VerificationKey) { + this.account.verificationKey.set(vk); + } + + private async ensureAdminSignature() { + const admin = await Provable.witnessAsync(PublicKey, async () => { + let pk = await this.adminPublicKey.fetch(); + assert(pk !== undefined, "could not fetch admin public key"); + return pk; + }); + this.adminPublicKey.requireEquals(admin); + return AccountUpdate.createSigned(admin); + } + + // Validates if minting is allowed within circulation limit + @method.returns(Bool) + public async canMint(accountUpdate: AccountUpdate) { + await this.ensureAdminSignature(); + const totalMintAmount = this.totalMintAmount.getAndRequireEquals(); + const newTotalMintAmount = totalMintAmount.add( + accountUpdate.body.balanceChange.magnitude + ); + + this.totalMintAmount.set(newTotalMintAmount); + return newTotalMintAmount.lessThanOrEqual(UInt64.from(CIRCULATION_MAX)); + } + + @method.returns(Bool) + public async canChangeAdmin(_admin: PublicKey) { + await this.ensureAdminSignature(); + return Bool(true); + } + + @method.returns(Bool) + public async canPause(): Promise { + await this.ensureAdminSignature(); + return Bool(true); + } + + @method.returns(Bool) + public async canResume(): Promise { + await this.ensureAdminSignature(); + return Bool(true); + } + + @method.returns(Bool) + public async canChangeVerificationKey(_vk: VerificationKey): Promise { + await this.ensureAdminSignature(); + return Bool(true); + } +} diff --git a/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json b/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json new file mode 100755 index 0000000..4e2be40 --- /dev/null +++ b/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json @@ -0,0 +1,9 @@ +{ + "id": "y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE", + "address": "B62qpN6sE9Bg9vzYVfs4ZBajgnv2sobb8fy76wZPB5vWM27s9GgtUTA", + "name": "Httpz", + "symbol": "Httpz", + "decimal": "9", + "description": "Httpz Token in Mainnet", + "website": "https://claim.httpz.link/" +} \ No newline at end of file From 5e7f9c29d0091265a787ee9957f427c4a21a225d Mon Sep 17 00:00:00 2001 From: minahttpz Date: Fri, 3 Jan 2025 17:49:32 +0800 Subject: [PATCH 2/4] Update token.json --- token/mina_mainnet/token.json | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/token/mina_mainnet/token.json b/token/mina_mainnet/token.json index 585ffe7..0d984f5 100644 --- a/token/mina_mainnet/token.json +++ b/token/mina_mainnet/token.json @@ -1,12 +1 @@ -[ - { - "id": "xvoiUpngKPVLAqjqKb5qXQvQBmk9DncPEaGJXzehoRSNrDB45r", - "address": "B62qjZkcgoTT4W1KB2GvmRxe4EX5W5quTDyzRiFjRPJXbhFAG1m2rkt", - "name": "TEST", - "symbol": "pqhx2", - "decimal": "8", - "description": "Auro test token in Mainnet", - "website":"https://www.aurowallet.com/", - "fungibleTokenVersion": "1.1.0" - } -] \ No newline at end of file +{"id":"y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE","address":"B62qpN6sE9Bg9vzYVfs4ZBajgnv2sobb8fy76wZPB5vWM27s9GgtUTA","name":"Httpz","symbol":"Httpz","decimal":"9","description":"Httpz Token in Mainnet","website":"https://claim.httpz.link/","fungibleTokenVersion":"1.1.0"} From a7a0e4fa2c6cd4c01ba506b5f6bee99d70810d3b Mon Sep 17 00:00:00 2001 From: minahttpz Date: Fri, 3 Jan 2025 17:51:12 +0800 Subject: [PATCH 3/4] Delete token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json --- .../token.json | 9 --------- 1 file changed, 9 deletions(-) delete mode 100755 token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json diff --git a/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json b/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json deleted file mode 100755 index 4e2be40..0000000 --- a/token/mina_mainnet/assets/y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE/token.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "id": "y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE", - "address": "B62qpN6sE9Bg9vzYVfs4ZBajgnv2sobb8fy76wZPB5vWM27s9GgtUTA", - "name": "Httpz", - "symbol": "Httpz", - "decimal": "9", - "description": "Httpz Token in Mainnet", - "website": "https://claim.httpz.link/" -} \ No newline at end of file From 696123f219726d809a421a482525a21f20e3281b Mon Sep 17 00:00:00 2001 From: minahttpz Date: Fri, 3 Jan 2025 18:00:57 +0800 Subject: [PATCH 4/4] Update token.json --- token/mina_mainnet/token.json | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/token/mina_mainnet/token.json b/token/mina_mainnet/token.json index 0d984f5..d746996 100644 --- a/token/mina_mainnet/token.json +++ b/token/mina_mainnet/token.json @@ -1 +1,13 @@ -{"id":"y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE","address":"B62qpN6sE9Bg9vzYVfs4ZBajgnv2sobb8fy76wZPB5vWM27s9GgtUTA","name":"Httpz","symbol":"Httpz","decimal":"9","description":"Httpz Token in Mainnet","website":"https://claim.httpz.link/","fungibleTokenVersion":"1.1.0"} +[ + { + "id": "xvoiUpngKPVLAqjqKb5qXQvQBmk9DncPEaGJXzehoRSNrDB45r", + "address": "B62qjZkcgoTT4W1KB2GvmRxe4EX5W5quTDyzRiFjRPJXbhFAG1m2rkt", + "name": "TEST", + "symbol": "pqhx2", + "decimal": "8", + "description": "Auro test token in Mainnet", + "website":"https://www.aurowallet.com/", + "fungibleTokenVersion": "1.1.0" + }, + {"id":"y96qmT865fCMGGHdKAQ448uUwqs7dEfqnGBGVrv3tiRKTC2hxE","address":"B62qpN6sE9Bg9vzYVfs4ZBajgnv2sobb8fy76wZPB5vWM27s9GgtUTA","name":"Httpz","symbol":"Httpz","decimal":"9","description":"Httpz Token in Mainnet","website":"https://claim.httpz.link/","fungibleTokenVersion":"1.1.0"} +]