# API methods

## Utility Functions <a href="#signature-generation" id="signature-generation"></a>

### Generate Signatures

Before using API methods that require signatures, you'll need to generate them using the provided utility function:

```go
import (
    onemoney "github.com/1Money-Co/1money-go-sdk"
    "github.com/ethereum/go-ethereum/common"
    "math/big"
)

// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

client := onemoney.NewTestClient()

// Get latest checkpoint
latestCheckpoint, err := client.GetCheckpointNumber(context.Background())
if err != nil {
    t.Fatalf("Failed to get latest checkpoint number: %v", err)
}

// Example: Generate signature for a payment transaction
paymentPayload := onemoney.PaymentPayload{
    ChainID:   1,
    Nonce:     1,
    Recipient: common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Value:     big.NewInt(1000000000),
    Token:     common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
}

signature, err := client.SignMessage(paymentPayload, privateKey)
if err != nil {
    // Handle error
    panic("Failed to generate signature: " + err.Error())
}

// The signature object will have the correct r, s, v format
fmt.Printf("Generated signature: %+v\n", signature)
```

### Get Account Nonce <a href="#id-1-get-account-nonce" id="id-1-get-account-nonce"></a>

```go
address := "0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"
account, err := client.GetAccount(address)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Account nonce: %d\n", account.Nonce)
```

### Get Token Metadata <a href="#id-2-get-token-metadata" id="id-2-get-token-metadata"></a>

```go
tokenAddress := "0x2cd8999Be299373D7881f4aDD11510030ad1412F"
tokenMetadata, err := client.GetToken(tokenAddress)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Token metadata: %+v\n", tokenMetadata)
```

### Get Current Checkpoint <a href="#id-3-get-current-checkpoint" id="id-3-get-current-checkpoint"></a>

```go
checkpoint, err := client.GetCheckpointNumber()
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Current checkpoint number: %d\n", checkpoint.Number)
```

## Transaction Methods <a href="#id-4-estimate-transaction-fee" id="id-4-estimate-transaction-fee"></a>

### Estimate Transaction Fee <a href="#id-4-estimate-transaction-fee" id="id-4-estimate-transaction-fee"></a>

```go
fromAddress := "0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"
value := "1000000000"
tokenAddress := "0x2cd8999Be299373D7881f4aDD11510030ad1412F"

fee, err := client.GetEstimateFee(fromAddress, tokenAddress, value)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Estimated fee: %s\n", fee.Fee)
```

### Get Transaction Details <a href="#id-5-get-transaction-details" id="id-5-get-transaction-details"></a>

```go
txHash := "0xf55f9525be94633b56f954d3252d52b8ef42f5fd5f9491b243708471c15cc40c"
transaction, err := client.GetTransactionByHash(txHash)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Transaction details: %+v\n", transaction)
```

### Get Transaction Receipt <a href="#id-6-get-transaction-receipt" id="id-6-get-transaction-receipt"></a>

```go
txHash := "0xf55f9525be94633b56f954d3252d52b8ef42f5fd5f9491b243708471c15cc40c"
receipt, err := client.GetTransactionReceipt(txHash)
if err != nil {
    // Handle error
    panic("Error: " + err.Error())
}
fmt.Printf("Transaction receipt: %+v\n", receipt)
```

## Payment Methods <a href="#id-7-submit-payment-transaction" id="id-7-submit-payment-transaction"></a>

### Submit Payment Transaction <a href="#id-7-submit-payment-transaction" id="id-7-submit-payment-transaction"></a>

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

client := onemoney.NewTestClient()

// Get latest checkpoint
latestCheckpoint, err := client.GetCheckpointNumber(context.Background())
if err != nil {
    t.Fatalf("Failed to get latest checkpoint number: %v", err)
}

// Create payment payload
payload := onemoney.PaymentPayload{
    ChainID:   1,
    Nonce:     1,
    Recipient: common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Value:     big.NewInt(1000000000),
    Token:     common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create payment request
req := &onemoney.PaymentRequest{
    PaymentPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Submit payment
response, err := client.SendPayment(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Payment transaction hash: %s\n", response.Hash)
```

## Token Management Methods <a href="#id-9-token-management-methods" id="id-9-token-management-methods"></a>

### **Issue New Token**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create token issue payload
payload := onemoney.TokenIssuePayload{
    ChainID:         1,
    Nonce:           1,
    Name:            "My Token",
    Symbol:          "MTK",
    Decimals:        18,
    MasterAuthority: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create issue token request
req := &onemoney.IssueTokenRequest{
    TokenIssuePayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Issue token
response, err := client.IssueToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Token issued: %+v\n", response)
```

### **Mint Tokens**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create mint payload
payload := onemoney.TokenMintPayload{
    ChainID:   1,
    Nonce:     1,
    Token:     common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Recipient: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
    Value:     big.NewInt(1000000000000000000), // 1 token with 18 decimals
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create mint request
req := &onemoney.MintTokenRequest{
    TokenMintPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Mint tokens
response, err := client.MintToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Mint transaction hash: %s\n", response.Hash)
```

### **Burn Tokens**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create burn payload
payload := onemoney.TokenBurnPayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Value:   big.NewInt(1000000000000000000), // 1 token with 18 decimals
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create burn request
req := &onemoney.BurnTokenRequest{
    TokenBurnPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Burn tokens
response, err := client.BurnToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Burn transaction hash: %s\n", response.Hash)
```

### **Update Token Metadata**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create metadata payload
payload := onemoney.UpdateMetadataPayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Name:    "Updated Token Name",
    URI:     "https://example.com/metadata",
    AdditionalMetadata: []onemoney.AdditionalMetadata{
        {
            Key:   "website",
            Value: "https://example.com",
        },
    },
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create metadata update request
req := &onemoney.UpdateMetadataRequest{
    UpdateMetadataPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update metadata
response, err := client.UpdateTokenMetadata(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Metadata update transaction hash: %s\n", response.Hash)
```

### **Set Token Blacklist Status**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create blacklist payload
payload := onemoney.TokenBlacklistPayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Address: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
    Action:  onemoney.ManageListActionRemove,
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create blacklist request
req := &onemoney.SetTokenBlacklistRequest{
    TokenBlacklistPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update blacklist status
response, err := client.SetTokenBlacklist(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Blacklist update transaction hash: %s\n", response.Hash)
```

### **Grant Token Authority**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create authority payload
payload := onemoney.TokenAuthorityPayload{
    ChainID:        1,
    Nonce:          1,
    Token:          common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    AuthorityAddress: common.HexToAddress("0x9E1E9688A44D058fF181Ed64ddFAFbBE5CC74ff3"),
    Action:         onemoney.Grant, // Use onemoney.Revoke to remove authority
    AuthorityType:  onemoney.AuthorityTypeMasterMintBurn,
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create authority request
req := &onemoney.TokenAuthorityRequest{
    TokenAuthorityPayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update authority
response, err := client.SetTokenAuthority(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Authority update transaction hash: %s\n", response.Hash)
```

### **Pause/Unpause Token**

```go
// Your private key (DO NOT share or commit your private key)
privateKey := "YOUR_PRIVATE_KEY"

// Create pause payload
payload := onemoney.TokenPausePayload{
    ChainID: 1,
    Nonce:   1,
    Token:   common.HexToAddress("0x2cd8999Be299373D7881f4aDD11510030ad1412F"),
    Action:  onemoney.Pause, // Use onemoney.Unpause to unpause
}

// Generate signature
signature, err := client.SignMessage(payload, privateKey)
if err != nil {
    panic("Failed to generate signature: " + err.Error())
}

// Create pause request
req := &onemoney.TokenPauseRequest{
    TokenPausePayload: payload,
    Signature: onemoney.Signature{
        R: signature.R,
        S: signature.S,
        V: signature.V,
    },
}

// Update pause status
response, err := client.PauseToken(req)
if err != nil {
    panic("Error: " + err.Error())
}
fmt.Printf("Pause status update transaction hash: %s\n", response.Hash)
```

## Error Handling <a href="#error-handling" id="error-handling"></a>

All API methods return an error as the second return value. Always check for errors before using the returned data:

```go
result, err := client.GetCheckpointNumber()
if err != nil {
    // Handle the error appropriately
    log.Fatalf("API request failed: %v", err)
}
// Use result safely now that we've checked for errors
fmt.Printf("Current checkpoint: %d\n", result.Number)
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://developer.1moneynetwork.com/integrations/sdks/golang/api-methods.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.